pimath 0.0.133 → 0.1.0

package/dist/maths/algebra/equation.d.ts

@@ -1,120 +0,0 @@
-import { Fraction } from '../coefficients/fraction';
-import { literalType } from './monom';
-import { Polynom } from './polynom';
-
-/**
- * Equation is a class to manage equations...
- */
-export interface ISolution {
-    tex: string;
-    display: string;
-    value: number;
-    exact: unknown;
-}
-export declare enum PARTICULAR_SOLUTION {
-    real = "\\mathbb{R}",
-    varnothing = "\\varnothing"
-}
-export declare class Equation {
-    private _polynom;
-    private _varnothing;
-    private _real;
-    private _left;
-    private _right;
-    private _sign;
-    private _solutions;
-    private _randomizeDefaults;
-    /**
-     * Create an Equation using two polynoms.
-     * Markdown *support* is cool
-     * @param equations
-     */
-    constructor(...equations: unknown[]);
-    get left(): Polynom;
-    set left(value: Polynom);
-    get right(): Polynom;
-    set right(value: Polynom);
-    get sign(): string;
-    set sign(value: string);
-    get solutions(): ISolution[];
-    get isEquation(): boolean;
-    get solution(): string;
-    get isReal(): boolean;
-    get isVarnothing(): boolean;
-    get signAsTex(): string;
-    get tex(): string;
-    get display(): string;
-    get raw(): string;
-    get variables(): string[];
-    get numberOfVars(): number;
-    get randomizeDefaults(): {
-        [key: string]: number | string | boolean;
-    };
-    set randomizeDefaults(value: {
-        [key: string]: number | string | boolean;
-    });
-    static makeSolutionsUnique(solutions: ISolution[], sorted?: boolean): ISolution[];
-    hasVariable: (letter: string) => boolean;
-    parse: (equationString: string) => Equation;
-    create: (left: Polynom, right: Polynom, sign?: string) => Equation;
-    clone: () => Equation;
-    randomize: (opts?: {}, sign?: string) => Equation;
-    /**
-     * Reorder will move all monoms containing a letter on the left, all the other on the right.
-     */
-    moveLeft: () => Equation;
-    reorder: (allLeft?: boolean) => Equation;
-    /**
-     * Multiply by the lcm denominator and divide by the gcm numerators.
-     */
-    simplify: () => Equation;
-    /**
-     * Reorder the polynom to have only one letter on the left, the rest on the right.
-     * @param letter
-     */
-    isolate: (letter?: string) => Equation | false;
-    replaceBy: (letter: string, P: Polynom) => Equation;
-    /**
-     * Multiple an equation by a fraction value.
-     * @param value
-     */
-    multiply: (value: unknown) => Equation;
-    /**
-     * divide an equation by a given value (transformed as a fraction)
-     *
-     * ```
-     * 8x+10=6x \vert 2
-     * 4x+5=3x
-     * ```
-     *
-     * |>Alternatively with $3x-4$ maybe it's working ?
-     * $$\frac{3x}{5}$$
-     *
-     * @param value
-     * @returns {Equation}
-     */
-    divide: (value: unknown) => Equation;
-    /**
-     * Get the degree of the equation
-     * @param letter
-     */
-    degree: (letter?: string) => Fraction;
-    /**
-     * Determine if the equation contains more than one letter/variable.
-     */
-    isMultiVariable: () => boolean;
-    letters: () => string[];
-    solve: () => Equation;
-    test: (values: literalType) => Boolean;
-    isSameAs: (equ: Equation) => Boolean;
-    isLinearTo: (equ: Equation) => Boolean;
-    private _findSign;
-    private _formatSign;
-    private _reverseSign;
-    private isGreater;
-    private isStrictEqual;
-    private isAlsoEqual;
-    private _solveDegree1;
-    private _solveDegree2;
-    private _solveDegree3plus;
-}

package/dist/maths/algebra/linearSystem.d.ts

@@ -1,40 +0,0 @@
-import { Fraction } from '../coefficients/fraction';
-import { Equation } from './equation';
-
-export declare class LinearSystem {
-    private _equations;
-    private _letters;
-    private _resolutionSteps;
-    private _solutions;
-    constructor(...equationStrings: (string | Equation)[]);
-    get equations(): Equation[];
-    set equations(value: Equation[]);
-    get letters(): string;
-    set letters(value: string);
-    get isSolvable(): boolean;
-    get variables(): string[];
-    get tex(): string;
-    get solution(): string;
-    get solutionAsDisplay(): string;
-    get resolutionSteps(): {
-        [p: string]: {
-            equations: Equation[];
-            operations: string[][];
-        }[];
-    };
-    buildTex: (equations: Equation[], operators?: (string[])[]) => string;
-    stepTex: (letter: string) => string;
-    parse: (...equations: (string | Equation)[]) => LinearSystem;
-    clone: () => LinearSystem;
-    reorder: () => LinearSystem;
-    solve: (withResolution?: boolean) => LinearSystem;
-    mergeEquations: (eq1: Equation, eq2: Equation, factor1: Fraction, factor2: Fraction) => Equation;
-    private _findLetters;
-    private _linearReduction;
-    /**
-     * Linear reduction of the equations to have only one letter
-     * @param letter    letter to isolate
-     * @private
-     */
-    private _solveOneLetter;
-}

package/dist/maths/algebra/logicalset.d.ts

@@ -1,28 +0,0 @@
-/**
- * Polynom module contains everything necessary to handle polynoms.
- * @module Logicalset
- */
-/**
- * Polynom class can handle polynoms, reorder, resolve, ...
- */
-export declare class Logicalset {
-    private _rawString;
-    private _rpn;
-    /**
-     *
-     * @param {string} value (optional) Default polynom to parse on class creation
-     */
-    constructor(value: string);
-    get isLogicalset(): boolean;
-    get rpn(): {
-        token: string;
-        tokenType: string;
-    }[];
-    get tex(): string;
-    evaluate(tokenSets: {
-        [key: string]: unknown[];
-    }, reference?: unknown[]): unknown[];
-    vennAB(): any[];
-    vennABC(): any[];
-    private parse;
-}

package/dist/maths/algebra/polynom.d.ts

@@ -1,155 +0,0 @@
-import { ISolution } from './equation';
-import { Fraction } from '../coefficients/fraction';
-import { Token } from '../shutingyard.ts';
-import { literalType, Monom } from './monom';
-
-export type PolynomParsingType = string | Polynom | number | Fraction | Monom;
-export interface IEuclidian {
-    quotient: Polynom;
-    reminder: Polynom;
-}
-/**
- * Polynom class can handle polynoms, reorder, resolve, ...
- * ```
- * let P = new Polynom('3x-4')
- * ```
- */
-export declare class Polynom {
-    private _rawString;
-    private _dirty_factors;
-    private _dirty_zeroes;
-    private _euclidianCache;
-    private _factors;
-    private _monoms;
-    private _texString;
-    private _zeroes;
-    /**
-     *
-     * @param {string} polynomString (optional) Default polynom to parse on class creation
-     * @param values
-     */
-    constructor(polynomString?: PolynomParsingType, ...values: unknown[]);
-    get dirty_factors(): boolean;
-    set dirty_factors(value: boolean);
-    get dirty_zeroes(): boolean;
-    set dirty_zeroes(value: boolean);
-    get euclidianCache(): {
-        [p: string]: IEuclidian;
-    };
-    set euclidianCache(value: {
-        [p: string]: IEuclidian;
-    });
-    get factors(): Polynom[];
-    set factors(value: Polynom[]);
-    get monoms(): Monom[];
-    set monoms(M: Monom[]);
-    get texString(): string;
-    get zeroes(): ISolution[];
-    get texFactors(): string;
-    get displayFactors(): string;
-    get length(): number;
-    get display(): string;
-    get raw(): string;
-    get tex(): string;
-    get isMultiVariable(): boolean;
-    get variables(): string[];
-    get numberOfVars(): number;
-    get plotFunction(): string;
-    mark_as_dirty: () => void;
-    addToken: (stack: Polynom[], element: Token) => void;
-    /**
-     * Parse a string to a polynom.
-     * @param inputStr
-     * @param values: as string, numbers or fractions
-     */
-    parse: (inputStr: PolynomParsingType, ...values: unknown[]) => Polynom;
-    /**
-     * Clone the polynom
-     */
-    clone: () => Polynom;
-    /**
-     * Set the polynom to zero.
-     * @returns {this}
-     */
-    zero: () => Polynom;
-    one: () => Polynom;
-    empty: () => Polynom;
-    opposed: () => Polynom;
-    add: (...values: unknown[]) => Polynom;
-    subtract: (...values: unknown[]) => Polynom;
-    multiply: (value: unknown) => Polynom;
-    /**
-     * Divide the current polynom by another polynom.
-     * @param P
-     * returns {quotient: Polynom, reminder: Polynom}
-     */
-    euclidian: (P: Polynom) => IEuclidian;
-    divide: (value: unknown) => Polynom;
-    pow: (nb: number) => Polynom;
-    /**
-     * Compare the current coefficient with another coefficient
-     * @param P
-     * @param sign (string| default is =): authorized values: =, <, <=, >, >= with some variations.
-     */
-    compare: (P: Polynom, sign?: string) => boolean;
-    isZero(): boolean;
-    isOne(): boolean;
-    isEqual: (P: Polynom) => boolean;
-    isSameAs: (P: Polynom) => boolean;
-    isOpposedAt: (P: Polynom) => boolean;
-    isFactorized: (polynomString: string, soft?: boolean) => boolean;
-    isReduced: (polynomString: string) => Boolean;
-    isDeveloped: (polynomString: string) => Boolean;
-    reduce: () => Polynom;
-    reorder: (letter?: string, revert?: boolean) => Polynom;
-    degree: (letter?: string) => Fraction;
-    letters: () => string[];
-    /**
-     * Replace a variable (letter) by a polynom.
-     * @param letter
-     * @param P
-     */
-    replaceBy: (letter: string, P: Polynom) => Polynom;
-    evaluate: (values: literalType | Fraction | number) => Fraction;
-    evaluateAsNumeric: (values: number | {
-        [Key: string]: number;
-    }) => number;
-    derivative: (letter?: string) => Polynom;
-    primitive: (letter?: string) => Polynom;
-    integrate: (a: Fraction | number, b: Fraction | number, letter?: string) => Fraction;
-    /**
-     * Factorize a polynom and store the best results in factors.
-     * @param maxValue Defines the greatest value to search to (default is 20).
-     */
-    factorize: (letter?: string) => Polynom[];
-    isDividableBy: (div: Polynom) => boolean;
-    getZeroes: () => ISolution[];
-    monomByDegree: (degree?: Fraction | number, letter?: string) => Monom;
-    monomsByDegree: (degree?: number | Fraction, letter?: string) => Monom[];
-    monomByLetter: (letter: string) => Monom;
-    getDenominators: () => number[];
-    getNumerators: () => number[];
-    lcmDenominator: () => number;
-    gcdDenominator: () => number;
-    lcmNumerator: () => number;
-    gcdNumerator: () => number;
-    commonMonom: () => Monom;
-    limitToInfinity: (letter?: string) => Fraction;
-    limitToNegativeInfinity: (letter?: string) => Fraction;
-    private _getAllPotentialFactors;
-    private _parseString;
-    private genDisplay;
-    /**
-     * Main parse using a shutting yard class
-     * @param inputStr
-     */
-    private shutingYardToReducedPolynom;
-    private multiplyByPolynom;
-    private multiplyByFraction;
-    private multiplyByInteger;
-    private multiplyByMonom;
-    private divideByInteger;
-    private divideByFraction;
-    private _factorize2ndDegree;
-    private _factorizeByGroups;
-}

package/dist/maths/algebra/rational.d.ts

@@ -1,44 +0,0 @@
-import { StudyConfig } from './study';
-import { RationalStudy } from './study/rationalStudy';
-import { literalType } from './monom';
-import { Fraction } from '../coefficients/fraction';
-import { IEuclidian, Polynom } from './polynom';
-
-/**
- * Rational class can handle rational polynoms
- */
-export declare class Rational {
-    private _denominator;
-    private _numerator;
-    private _rawString;
-    /**
-     *
-     * @param numerator
-     * @param denominator
-     */
-    constructor(numerator?: Polynom | string, denominator?: Polynom | string);
-    get numerator(): Polynom;
-    get denominator(): Polynom;
-    get tex(): string;
-    get display(): string;
-    get texFactors(): string;
-    get displayFactors(): string;
-    get plotFunction(): string;
-    clone: () => Rational;
-    domain: () => string;
-    amplify: (P: Polynom) => Rational;
-    derivative: (letter?: string) => Rational;
-    factorize: (letter?: string) => Rational;
-    simplify: (P: Polynom) => Rational;
-    reduce: () => Rational;
-    opposed: () => Rational;
-    add: (R: Rational) => Rational;
-    subtract: (R: Rational) => Rational;
-    euclidian: () => IEuclidian;
-    limits: (value: Fraction | number, offset?: string, letter?: string) => Fraction;
-    evaluate: (values: literalType | Fraction | number) => Fraction;
-    evaluateAsNumeric: (values: number | {
-        [Key: string]: number;
-    }) => number;
-    study: (config?: StudyConfig | string) => RationalStudy;
-}

package/dist/maths/algebra/study/rationalStudy.d.ts

@@ -1,14 +0,0 @@
-import { Rational } from '../rational';
-import { ASYMPTOTE_POSITION, IAsymptote, ITableOfSigns, IZero, Study, StudyableFunction, StudyConfig } from '../study';
-
-export declare class RationalStudy extends Study {
-    constructor(fx: StudyableFunction, config?: StudyConfig | string);
-    makeZeroes(): IZero[];
-    makeSigns(): ITableOfSigns;
-    makeAsymptotes(): IAsymptote[];
-    _getHorizontalAsymptoteRelativePositon(deltaX: Rational, delta?: number): ASYMPTOTE_POSITION[];
-    makeDerivative(): ITableOfSigns;
-    makeVariation(): ITableOfSigns;
-    private _getZeroes;
-    private _getSigns;
-}

package/dist/maths/algebra/study.d.ts

@@ -1,140 +0,0 @@
-import { Polynom } from './polynom';
-import { ISolution } from './equation';
-import { Rational } from './rational';
-
-export type StudyableFunction = Rational;
-export declare enum ZEROTYPE {
-    ZERO = "z",
-    DEFENCE = "d",
-    NOTHING = "t"
-}
-export interface IZero extends ISolution {
-    extrema: FUNCTION_EXTREMA;
-    type: ZEROTYPE;
-}
-export declare enum ASYMPTOTE {
-    VERTICAL = "av",
-    HORIZONTAL = "ah",
-    SLOPE = "ao",
-    HOLE = "hole"
-}
-export declare enum ASYMPTOTE_POSITION {
-    "LT" = "LT",
-    "RT" = "RT",
-    "LB" = "LB",
-    "RB" = "RB"
-}
-export interface IAsymptote {
-    deltaX: StudyableFunction;
-    display: string;
-    fx: Polynom;
-    limits: string;
-    position: ASYMPTOTE_POSITION[];
-    tableOfSign: ITableOfSigns;
-    tex: string;
-    type: ASYMPTOTE;
-    zero: IZero;
-}
-export declare enum FUNCTION_EXTREMA {
-    MIN = "min",
-    MAX = "max",
-    FLAT = "flat",
-    NOTHING = ""
-}
-export interface IExtrema {
-    tex: {
-        x: string;
-        y: string;
-    };
-    type: FUNCTION_EXTREMA;
-    value: {
-        x: number;
-        y: number;
-    };
-}
-export interface ITableOfSigns {
-    extremes: {
-        [Key: string]: IExtrema;
-    };
-    factors: Polynom[];
-    fx: StudyableFunction;
-    signs: (string[])[];
-    tex: string;
-    type: TABLE_OF_SIGNS;
-    zeroes: IZero[];
-}
-export declare enum TABLE_OF_SIGNS {
-    SIGNS = "signs",
-    GROWS = "grows",
-    VARIATIONS = "variatins"
-}
-export interface StudyConfig {
-    asymptotes?: boolean;
-    derivative?: boolean;
-    domain?: boolean;
-    name?: string;
-    variable?: string;
-    signs?: boolean;
-    variations?: boolean;
-}
-/**
- * The study class is a "function study" class that will get:
- * fx               : get the function
- * domain           : string
- * zeroes           : Object (tex, IZero)
- * signs            : table of signs + tex output  using tkz-tab
- * av               : vertical asymptotic
- * ah               : horizontal asymptotic
- * ao               : obliques
- * deltaX           : position relative
- * dx               : derivative
- * grows            : growing table + tex output  using tkz-tab
- * ddx              : dérivée seconde
- * variations       : variation table + tex output  using tkz-tab
- */
-export declare class Study {
-    fx: StudyableFunction;
-    private _asymptotes;
-    private _derivative;
-    private _signs;
-    private _variations;
-    private _zeroes;
-    private _config;
-    private _name;
-    constructor(fx: StudyableFunction, config?: StudyConfig | string);
-    get name(): string;
-    set name(value: string);
-    get config(): StudyConfig;
-    set config(value: StudyConfig);
-    get zeroes(): IZero[];
-    get domain(): string;
-    get signs(): ITableOfSigns;
-    get asymptotes(): IAsymptote[];
-    get derivative(): ITableOfSigns;
-    get texSigns(): string;
-    get texGrows(): string;
-    get texVariations(): string;
-    makeStudy: () => void;
-    indexOfZero: (zeroes: IZero[], zero: IZero | ISolution) => number;
-    makeOneLineForSigns: (factor: Polynom, zeroes: IZero[], zeroSign: ZEROTYPE) => string[];
-    makeSignsResult: (signs: (string[])[]) => string[];
-    makeGrowsResult: (tos: ITableOfSigns) => {
-        growsLine: string[];
-        extremes: {
-            [Key: string]: IExtrema;
-        };
-    };
-    makeVariationsResult: (tos: ITableOfSigns) => {
-        varsLine: string[];
-        extremes: {
-            [Key: string]: IExtrema;
-        };
-    };
-    makeZeroes(): IZero[];
-    makeSigns(): ITableOfSigns;
-    makeAsymptotes(): IAsymptote[];
-    makeDerivative(): ITableOfSigns;
-    makeVariation(): ITableOfSigns;
-    drawCode: () => string;
-    private _makeTexFromTableOfSigns;
-}

package/dist/maths/geometry/line.d.ts

@@ -1,102 +0,0 @@
-import { Equation } from '../algebra/equation';
-import { Fraction } from '../coefficients/fraction';
-import { Point } from './point';
-import { Vector } from './vector';
-
-export declare enum LinePropriety {
-    None = 0,
-    Parallel = "parallel",
-    Perpendicular = "perpendicular",
-    Tangent = "tangent"
-}
-export declare class Line {
-    static PERPENDICULAR: LinePropriety;
-    static PARALLEL: LinePropriety;
-    private _referencePropriety;
-    private _referenceLine;
-    private _reduceBeforeDisplay;
-    private _a;
-    private _b;
-    private _c;
-    private _OA;
-    private _d;
-    private _n;
-    private _exists;
-    /**
-     * Value can be a mix of:
-     *
-     * @param values
-     */
-    constructor(...values: unknown[]);
-    get a(): Fraction;
-    set a(value: Fraction);
-    get b(): Fraction;
-    set b(value: Fraction);
-    get c(): Fraction;
-    set c(value: Fraction);
-    get OA(): Point;
-    set OA(value: Point);
-    get d(): Vector;
-    set d(value: Vector);
-    get n(): Vector;
-    get exists(): boolean;
-    get equation(): Equation;
-    get system(): {
-        x: Equation;
-        y: Equation;
-    };
-    get tex(): {
-        canonical: string;
-        mxh: string;
-        parametric: string;
-        equation: string;
-        system: string;
-    };
-    get reduceBeforeDisplay(): boolean;
-    set reduceBeforeDisplay(value: boolean);
-    get display(): {
-        canonical: string;
-        mxh: string;
-        parametric: string;
-    };
-    get normal(): Vector;
-    get director(): Vector;
-    get slope(): Fraction;
-    get height(): Fraction;
-    randomPoint: (k?: number) => Point;
-    randomNearPoint: (k?: number) => Point;
-    /**
-     * Parse data to a line
-     * @param {any} values
-     * @returns {Line}
-     */
-    parse: (...values: unknown[]) => Line;
-    parseEquation: (equ: Equation) => Line;
-    parseByCoefficient: (a: Fraction | number, b: Fraction | number, c: Fraction | number) => Line;
-    parseByPointAndVector: (P: Point, d: Vector) => Line;
-    parseByPointAndNormal: (P: Point, n: Vector) => Line;
-    parseByPointAndLine: (P: Point, L: Line, orientation?: LinePropriety) => Line;
-    clone: () => Line;
-    isOnLine: (pt: Point) => Boolean;
-    isParallelTo: (line: Line) => Boolean;
-    isSameAs: (line: Line) => Boolean;
-    isPerpendicularTo: (line: Line) => Boolean;
-    isVertical: () => Boolean;
-    simplify: () => Line;
-    simplifyDirection: () => Line;
-    intersection: (line: Line) => {
-        point: Point;
-        hasIntersection: boolean;
-        isParallel: boolean;
-        isSame: boolean;
-    };
-    distanceTo(pt: Point): {
-        value: number;
-        fraction: Fraction;
-        tex: string;
-    };
-    hitSegment(A: Point, B: Point): boolean;
-    getValueAtX: (value: Fraction | number) => Fraction;
-    getValueAtY: (value: Fraction | number) => Fraction;
-    canonicalAsFloatCoefficient(decimals: number): string;
-}

package/dist/maths/geometry/point.d.ts

@@ -1,36 +0,0 @@
-import { Fraction } from '../coefficients/fraction';
-import { Vector } from './vector';
-import { Line } from './line';
-
-export declare class Point {
-    private _x;
-    private _y;
-    private _exist;
-    constructor(...values: unknown[]);
-    get x(): Fraction;
-    set x(value: Fraction);
-    get y(): Fraction;
-    set y(value: Fraction);
-    get tex(): string;
-    get display(): string;
-    get asVector(): Vector;
-    get key(): string;
-    static pmatrix: (a: any, b: any, c?: any) => string;
-    parse: (...values: unknown[]) => Point;
-    clone: () => Point;
-    zero: () => Point;
-    origin: () => Point;
-    middleOf: (P1: Point, P2: Point) => Point;
-    translate: (value: {
-        x: number | Fraction;
-        y: number | Fraction;
-    }) => Point;
-    texValues: (numberOfDigits: number) => string;
-    distanceTo: (item: Point | Line) => {
-        value: number;
-        fraction: Fraction;
-        tex: string;
-    };
-    isInListOfPoints: (list: Point[]) => boolean;
-    isEqual: (pt: Point) => boolean;
-}