pimath 0.1.10 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pimath",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "A math library for teacher :)",
   "type": "module",
   "main": "dist/index.js",

package/types/algebra/equation.d.ts

@@ -0,0 +1,101 @@
+import { IAlgebra, IEquation, InputAlgebra, InputValue, IPiMathObject, ISolution, literalType } from '../pimath.interface';
+import { Fraction } from '../coefficients/fraction';
+import { Polynom } from './polynom';
+export type EQUATION_SIGN = "=" | "<=" | ">=" | "<" | ">";
+export declare class Equation implements IPiMathObject<Equation>, IEquation<Equation>, IAlgebra<Equation> {
+    #private;
+    constructor(equation: InputAlgebra<Polynom> | Equation);
+    constructor(left: InputAlgebra<Polynom>, right: InputAlgebra<Polynom>, sign?: EQUATION_SIGN);
+    parse: (equationString: string) => this;
+    create: (left: Polynom, right: Polynom, sign?: string) => this;
+    clone: () => Equation;
+    /**
+     * Add a value to the equation
+     * if value is an equation, add the left part to the left part of the equation
+     * and the right part to the right part of the equation
+     * if value is a string, try to create an equation
+     * if it fails, create a polynom and add it to the left and right part of the equation
+     * @param value | Polynom | Monom | Fraction | string | monom
+     */
+    add(value: InputValue<Equation | Polynom>): this;
+    /**
+     * Get the degree of the equation
+     * @param letter
+     */
+    degree: (letter?: string) => Fraction;
+    /**
+     * 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: InputValue<Fraction>) => this;
+    /**
+     * Create an Equation using two polynoms.
+     * Markdown *support* is cool
+     * @param values
+     * @param asNumeric
+     */
+    evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean | undefined): boolean;
+    /**
+     * Determine if the equation contains a variable.
+     * @param letter
+     */
+    hasVariable: (letter: string) => boolean;
+    isEqual(value: InputValue<Equation>): boolean;
+    isLinearTo: (equ: Equation) => boolean;
+    /**
+     * Determine if the equation contains more than one letter/variable.
+     */
+    isMultiVariable: () => boolean;
+    isEqualTo: (equ: Equation) => boolean;
+    /**
+     * Reorder the polynom to have only one letter on the left, the rest on the right.
+     * @param letter
+     */
+    isolate: (letter?: string) => this | false;
+    letters: () => string[];
+    /**
+     * Reorder will move all monoms containing a letter on the left, all the other on the right.
+     */
+    moveLeft: () => this;
+    /**
+     * Multiple an equation by a fraction value.
+     * @param value
+     */
+    multiply: (value: InputValue<Fraction>) => this;
+    pow(value: number): this;
+    opposite: () => this;
+    reduce(): this;
+    reorder: (allLeft?: boolean) => this;
+    replaceBy: (letter: string, P: Polynom) => this;
+    /**
+     * Multiply by the lcm denominator and divide by the gcm numerators.
+     */
+    simplify: () => this;
+    solve: () => ISolution[];
+    split(): [Polynom, Polynom];
+    subtract(value: InputValue<Equation | Polynom>): this;
+    test: (values: literalType<Fraction>) => boolean;
+    static isEquationString(equationString: string): boolean;
+    static makeSolutionsUnique(solutions: ISolution[], sorted?: boolean): ISolution[];
+    get display(): string;
+    get left(): Polynom;
+    set left(value: Polynom);
+    get numberOfVars(): number;
+    get right(): Polynom;
+    set right(value: Polynom);
+    get sign(): string;
+    set sign(value: string);
+    get signAsTex(): string;
+    get tex(): string;
+    get variables(): string[];
+}

package/types/algebra/equation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equation.d.ts","sourceRoot":"","sources":["../../src/algebra/equation.ts"],"names":[],"mappings":"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"}

package/types/algebra/equationSolver.d.ts

@@ -0,0 +1,9 @@
+import { ISolution } from '../pimath.interface';
+import { Polynom } from './polynom';
+import { Equation } from './equation';
+export declare class EquationSolver {
+    #private;
+    constructor(left: Polynom | Equation, right?: Polynom, variable?: string);
+    solve(): ISolution[];
+    solveAsCardan(): ISolution[];
+}

package/types/algebra/equationSolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equationSolver.d.ts","sourceRoot":"","sources":["../../src/algebra/equationSolver.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAa,SAAS,EAAC,MAAM,qBAAqB,CAAA;AAC9D,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGtC,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAA;AAExC,qBAAa,cAAc;;gBAIX,IAAI,EAAE,OAAO,GAAG,QAAQ,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,QAAQ,SAAM;IAW9D,KAAK,IAAI,SAAS,EAAE;IAuBpB,aAAa,IAAI,SAAS,EAAE;CA8TtC"}

package/types/algebra/factor.d.ts

@@ -0,0 +1,46 @@
+import { IAlgebra, IExpression, InputAlgebra, InputValue, IPiMathObject, ISolution, literalType, TABLE_OF_SIGNS } from '../pimath.interface';
+import { Fraction } from '../coefficients/fraction';
+import { Polynom } from './polynom';
+export declare class Factor implements IPiMathObject<Factor>, IExpression<Factor>, IAlgebra<Factor> {
+    #private;
+    constructor(value: InputAlgebra<Polynom> | Factor, power?: InputValue<Fraction>);
+    parse(): Factor;
+    clone(): Factor;
+    add(): Factor;
+    get withPower(): this;
+    get withRoot(): this;
+    get asSingle(): this;
+    degree(letter?: string): Fraction;
+    derivative(): Factor[];
+    develop(): Polynom;
+    get display(): string;
+    divide(value: InputAlgebra<Factor | Polynom>): this;
+    evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean): number | Fraction;
+    hasVariable(letter: string): boolean;
+    inverse(): this;
+    isEqual(value: Factor): boolean;
+    isOne(): boolean;
+    isSameAs(value: InputAlgebra<Factor | Polynom>): boolean;
+    isZero(): boolean;
+    multiply(value: InputAlgebra<Factor | Polynom>): this;
+    one(): this;
+    opposite(): Factor;
+    get polynom(): Polynom;
+    set polynom(value: Polynom);
+    pow(value: number | Fraction): this;
+    get power(): Fraction;
+    set power(value: InputValue<Fraction>);
+    primitive(): Factor;
+    reduce(): Factor;
+    root(value: number): this;
+    sqrt(): this;
+    subtract(): Factor;
+    get tex(): string;
+    get variables(): string[];
+    zero(): this;
+    tableOfSigns(roots?: ISolution[]): TABLE_OF_SIGNS;
+}
+export declare enum FACTOR_DISPLAY {
+    ROOT = 0,
+    POWER = 1
+}

package/types/algebra/factor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factor.d.ts","sourceRoot":"","sources":["../../src/algebra/factor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,UAAU,EACV,aAAa,EACb,SAAS,EACT,WAAW,EAAE,cAAc,EAC9B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC,qBAAa,MAAO,YAChB,aAAa,CAAC,MAAM,CAAC,EACrB,WAAW,CAAC,MAAM,CAAC,EACnB,QAAQ,CAAC,MAAM,CAAC;;gBAMJ,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC;IAmBxE,KAAK,IAAiC,MAAM;IAI5C,KAAK,IAAI,MAAM;IAIf,GAAG,IAAI,MAAM;IAIpB,IAAW,SAAS,IAAI,IAAI,CAG3B;IAED,IAAW,QAAQ,IAAI,IAAI,CAG1B;IACD,IAAW,QAAQ,IAAI,IAAI,CAG1B;IAEM,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ;IAIjC,UAAU,IAAI,MAAM,EAAE;IAoBtB,OAAO,IAAI,OAAO;IAQzB,IAAW,OAAO,IAAI,MAAM,CAyB3B;IAEM,MAAM,CAAC,KAAK,EAAE,YAAY,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,IAAI;IAkBnD,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAC,MAAM,GAAG,QAAQ,CAAC,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ;IAS/G,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIpC,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAO/B,KAAK,IAAI,OAAO;IAIhB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,MAAM,GAAG,OAAO,CAAC;IAc9C,MAAM,IAAI,OAAO;IAIjB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,IAAI;IAkBrD,GAAG,IAAI,IAAI;IAMX,QAAQ,IAAI,MAAM;IAIzB,IAAW,OAAO,IAAI,OAAO,CAE5B;IAED,IAAW,OAAO,CAAC,KAAK,EAAE,OAAO,EAEhC;IAEM,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI;IAK1C,IAAW,KAAK,IAAI,QAAQ,CAE3B;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,UAAU,CAAC,QAAQ,CAAC,EAE3C;IAEM,SAAS,IAAI,MAAM;IAInB,MAAM,IAAI,MAAM;IAIhB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKzB,IAAI,IAAI,IAAI;IAIZ,QAAQ,IAAI,MAAM;IAIzB,IAAW,GAAG,IAAI,MAAM,CAyBvB;IAED,IAAW,SAAS,IAAI,MAAM,EAAE,CAE/B;IAEM,IAAI,IAAI,IAAI;IAMZ,YAAY,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,GAAG,cAAc;CAwB3D;AAED,oBAAY,cAAc;IACtB,IAAI,IAAA;IACJ,KAAK,IAAA;CACR"}

package/types/algebra/linearSystem.d.ts

@@ -0,0 +1,32 @@
+import { IAlgebra, IEquation, InputValue, IPiMathObject, ISolution, literalType } from '../pimath.interface';
+import { Fraction } from '../coefficients/fraction';
+import { Equation } from './equation';
+import { Polynom } from './polynom';
+export declare class LinearSystem implements IPiMathObject<LinearSystem>, IEquation<LinearSystem>, IAlgebra<LinearSystem> {
+    #private;
+    constructor(...values: (string | Equation)[]);
+    parse: (...equations: (string | Equation)[]) => this;
+    clone: () => LinearSystem;
+    static fromMatrix(matrix: InputValue<Fraction>[][], letters?: string): LinearSystem;
+    add(value: InputValue<LinearSystem | Equation | Polynom>, index?: number): this;
+    buildTex: (equations: Equation[], operators?: (string[])[]) => string;
+    degree(letter?: string | undefined): Fraction;
+    get display(): string;
+    get equations(): Equation[];
+    set equations(value: Equation[]);
+    evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean | undefined): number | Fraction;
+    hasVariable(letter: string): boolean;
+    isEqual(value: LinearSystem): boolean;
+    get isSolvable(): boolean;
+    get matrix(): [Fraction[][], Fraction[]];
+    mergeEquations: (eq1: Equation, eq2: Equation, factor1: Fraction, factor2: Fraction) => Equation;
+    multiply(value: InputValue<Fraction> | InputValue<Fraction>[], index?: number): this;
+    reduce(): LinearSystem;
+    reorder: () => this;
+    solve(): ISolution[];
+    solveMatrix: () => Fraction[];
+    subtract(value: InputValue<LinearSystem | Equation | Polynom>, index?: number): this;
+    get tex(): string;
+    get variables(): string[];
+    set variables(value: string | string[]);
+}

package/types/algebra/linearSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linearSystem.d.ts","sourceRoot":"","sources":["../../src/algebra/linearSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAA;AAC/G,OAAO,EAAC,QAAQ,EAAC,MAAM,0BAA0B,CAAA;AACjD,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAA;AAEnC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,qBAAa,YAAa,YAAW,aAAa,CAAC,YAAY,CAAC,EAC5D,SAAS,CAAC,YAAY,CAAC,EACvB,QAAQ,CAAC,YAAY,CAAC;;gBAOV,GAAG,MAAM,EAAE,CAAC,MAAM,GAAG,QAAQ,CAAC,EAAE;IAWrC,KAAK,iBAAkB,CAAC,MAAM,GAAG,QAAQ,CAAC,EAAE,KAAG,IAAI,CAOzD;IAEM,KAAK,QAAO,YAAY,CAG9B;WAEa,UAAU,CACpB,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,EAAE,EAAE,EAChC,OAAO,SAAQ,GAAG,YAAY;IAqB3B,GAAG,CAAC,KAAK,EAAE,UAAU,CAAC,YAAY,GAAG,QAAQ,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAqB/E,QAAQ,cAAe,QAAQ,EAAE,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,KAAG,MAAM,CAqD1E;IAEM,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ;IAIpD,IAAI,OAAO,WAGV;IAGD,IAAW,SAAS,IAAI,QAAQ,EAAE,CAEjC;IAED,IAAW,SAAS,CAAC,KAAK,EAJF,QAAQ,EAIN,EAEzB;IAEM,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAC,MAAM,GAAG,QAAQ,CAAC,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ;IAI3H,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIpC,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO;IAI5C,IAAW,UAAU,IAAI,OAAO,CAW/B;IAED,IAAW,MAAM,IAAI,CAAC,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAG9C;IAEM,cAAc,QAAS,QAAQ,OAAO,QAAQ,WAAW,QAAQ,WAAW,QAAQ,KAAG,QAAQ,CAWrG;IAEM,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAwBpF,MAAM,IAAI,YAAY;IAKtB,OAAO,QAAO,IAAI,CAMxB;IAED,KAAK,IAAI,SAAS,EAAE;IAIb,WAAW,QAAO,QAAQ,EAAE,CA0ClC;IAEM,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,YAAY,GAAG,QAAQ,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAqB3F,IAAW,GAAG,IAAI,MAAM,CAQvB;IAED,IAAW,SAAS,IAAI,MAAM,EAAE,CAE/B;IAED,IAAW,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAI5C;CA2CJ"}

package/types/algebra/logicalset.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Polynom class can handle polynoms, reorder, resolve, ...
+ */
+export declare class LogicalSet {
+    #private;
+    /**
+     *
+     * @param {string} value (optional) Default polynom to parse on class creation
+     */
+    constructor(value?: string);
+    parse: (value: string) => this;
+    evaluate(values: Record<string, boolean>): boolean;
+    get rpn(): {
+        token: string;
+        tokenType: string;
+    }[];
+    get tex(): string;
+    get variables(): string[];
+    vennAB(): string[];
+    vennABC(): string[];
+}

package/types/algebra/logicalset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logicalset.d.ts","sourceRoot":"","sources":["../../src/algebra/logicalset.ts"],"names":[],"mappings":"AASA,qBAAa,UAAU;;gBAOP,KAAK,CAAC,EAAE,MAAM;IAU1B,KAAK,UAAW,MAAM,KAAG,IAAI,CAO5B;IAED,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;IAgDlD,IAAI,GAAG,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,CAEhD;IAED,IAAI,GAAG,IAAI,MAAM,CAsEhB;IAED,IAAI,SAAS,IAAI,MAAM,EAAE,CAIxB;IAED,MAAM,IAAI,MAAM,EAAE;IASlB,OAAO,IAAI,MAAM,EAAE;CAiFtB"}

package/types/algebra/monom.d.ts

@@ -0,0 +1,168 @@
+import { IAlgebra, IAnalyse, IExpression, InputAlgebra, InputValue, IPiMathObject, literalType } from '../pimath.interface';
+import { Fraction } from '../coefficients/fraction';
+export declare class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse<Monom>, IAlgebra<Monom> {
+    #private;
+    constructor(value?: InputValue<Fraction>);
+    constructor(value?: Monom);
+    /**
+     * Parse a string to a monom. The string may include fraction.
+     * @param inputStr
+     */
+    parse(inputStr: InputAlgebra<Monom>): this;
+    /**
+     * Clone the current Monom.
+     */
+    clone: () => Monom;
+    static gcd: (...monoms: Monom[]) => Monom;
+    /**
+     * Multiply two monoms and return a NEW monom.
+     * @param monoms
+     */
+    static xMultiply: (...monoms: Monom[]) => Monom;
+    /**
+     * Add all similar monoms. If they aren't similar, they are simply skipped.
+     * @param M (Monom[]) The monoms to add.
+     */
+    add: (...M: InputAlgebra<Fraction>[]) => this;
+    /**
+     * Get the coefficient \\(k\\) of the Monom \\(k\\cdot x^{n}\\)
+     * @returns {Fraction}
+     */
+    get coefficient(): Fraction;
+    /**
+     * Set the coefficient \\(k\\) value of the monom
+     * @param {Fraction | number | string} F
+     */
+    set coefficient(F: InputValue<Fraction>);
+    containsRationalPower: () => boolean;
+    /**
+     * Get the degree of a monom. If no setLetter is given, the result will be the global degree.
+     * @param letter (string) Letter to get to degree (power)
+     */
+    degree: (letter?: string) => Fraction;
+    /**
+     * Derivative the monom
+     * @param letter
+     */
+    derivative: (letter?: string) => Monom;
+    /**
+     * This display getter is to be used in the polynom display getter
+     */
+    get display(): string;
+    /**
+     * Divide the current monoms by multiple monoms
+     * @param M (Monom[])
+     */
+    divide: (...M: InputAlgebra<Fraction>[]) => this;
+    get dividers(): Monom[];
+    /**
+     * Evaluate a monom. Each setLetter must be assigned to a Fraction.
+     * @param values    Dictionary of <setLetter: Fraction>
+     * @param asNumeric
+     */
+    evaluate: (values: literalType<number | Fraction> | InputValue<Fraction>, asNumeric?: boolean) => Fraction | number;
+    /**
+     * Determine if a monom contains a setLetter in it's literal part
+     * @param letter
+     */
+    hasVariable: (letter?: string) => boolean;
+    integrate(a: InputValue<Fraction>, b: InputValue<Fraction>, letter?: string | undefined): Fraction;
+    inverse: () => this;
+    isDivisible: (div: Monom) => boolean;
+    /**
+     * Determine if two monoms are equals
+     * @param M
+     */
+    isEqual: (M: Monom) => boolean;
+    isLiteralSquare: () => boolean;
+    /**
+     * Determine if the monom is one
+     */
+    isOne: () => boolean;
+    /**
+     * Determine if two monoms are similar
+     * @param M
+     */
+    isSameAs: (M: Monom) => boolean;
+    isSquare: () => boolean;
+    /**
+     * Determine if the monom is null
+     */
+    isZero: () => boolean;
+    /**
+     * Get the literal part of \\(x^{n_1}y^{n_2}\\) as dictionary \\[\\begin{array}{ll}x&=n_1\\\\y&=n_2\\end{array}\\]
+     * @returns {literalType}
+     */
+    get literal(): literalType<Fraction>;
+    /**
+     * Set the literal part of the monom. Must be a dictionary {x: Fraction, y: Fraction, ...}
+     * @param {literalType<Fraction>} L
+     */
+    set literal(L: literalType<Fraction>);
+    /**
+     * Get the literal square roots of the Monom.
+     * TODO: remove this getter ? Is it used and is it correct ?
+     * @returns {literalType<Fraction>}
+     */
+    get literalSqrt(): literalType<Fraction>;
+    /**
+     * Set the literal part of the monom from a string
+     * @param inputStr  String like x^2y^3
+     */
+    set literalStr(inputStr: string);
+    /**
+     * Multiple multiple monoms to the current monom
+     * @param M (Monom[]) The monoms to multiply to.
+     */
+    multiply: (...M: InputAlgebra<Fraction>[]) => this;
+    /**
+     * Create a one value monom
+     */
+    one: () => this;
+    /**
+     * Get the opposite
+     * Returns a monom.
+     */
+    opposite: () => this;
+    get plotFunction(): string;
+    /**
+     * Get the pow of a monom.
+     * @param nb (number) : Mathematical pow
+     */
+    pow: (nb: number | Fraction) => this;
+    primitive: (letter?: string) => Monom;
+    reduce: () => this;
+    removeVariable(letter: string): void;
+    /**
+     * Get the nth-root of the monom
+     */
+    root: () => this;
+    /**
+     * Set the power of a particular setLetter
+     * @param letter (string) Letter to change
+     * @param pow (number) Power of the setLetter (must be positive integer.
+     */
+    setLetter: (letter: string, pow: InputValue<Fraction>) => this;
+    /**
+     * Return the square root of a monom
+     */
+    sqrt: () => this;
+    /**
+     * Subtract multiple monoms
+     * @param M (Monom[]) The monoms to subtract
+     */
+    subtract: (...M: InputAlgebra<Fraction>[]) => this;
+    /**
+     * Get the tex output of the monom
+     */
+    get tex(): string;
+    /**
+     * Get the variables letters
+     */
+    get variables(): string[];
+    /**
+     * Create a zero value monom
+     */
+    zero: () => this;
+    private _getLiteralDividers;
+}

package/types/algebra/monom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monom.d.ts","sourceRoot":"","sources":["../../src/algebra/monom.ts"],"names":[],"mappings":"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"}

package/types/algebra/polyFactor.d.ts

@@ -0,0 +1,50 @@
+import { IAlgebra, IExpression, InputAlgebra, InputValue, IPiMathObject, ISolution, literalType, TABLE_OF_SIGNS } from '../pimath.interface';
+import { Fraction } from '../coefficients/fraction';
+import { Factor } from './factor';
+import { Polynom } from './polynom';
+export declare class PolyFactor implements IPiMathObject<PolyFactor>, IExpression<PolyFactor>, IAlgebra<PolyFactor> {
+    #private;
+    constructor(...values: (Factor | InputAlgebra<Polynom> | PolyFactor)[]);
+    parse(...values: (Factor | InputAlgebra<Polynom> | PolyFactor)[]): this;
+    clone(): PolyFactor;
+    static gcd(...values: PolyFactor[]): PolyFactor;
+    add(...values: PolyFactor[]): this;
+    get asPower(): this;
+    get asRoot(): this;
+    degree(letter?: string): Fraction;
+    get denominator(): Factor[];
+    derivative(): this;
+    develop(): Polynom;
+    get display(): string;
+    divide(value: PolyFactor): this;
+    evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean): number | Fraction;
+    get factors(): Factor[];
+    set factors(value: Factor[]);
+    fromPolynom(polynom: InputAlgebra<Polynom>, letter?: string): this;
+    getZeroes(): ISolution[];
+    hasVariable(letter: string): boolean;
+    inverse(): this;
+    isEqual(value: PolyFactor): boolean;
+    isOne(): boolean;
+    isZero(): boolean;
+    multiply(...values: PolyFactor[]): this;
+    get numerator(): Factor[];
+    one(): this;
+    opposite(): this;
+    pow(value: number | Fraction): this;
+    primitive(): PolyFactor;
+    reduce(): this;
+    root(value: number): this;
+    sort(): this;
+    sqrt(): this;
+    subtract(...values: PolyFactor[]): this;
+    tableOfSigns(): TABLE_OF_SIGNS & {
+        factors: {
+            factor: Factor;
+            tableOfSigns: TABLE_OF_SIGNS;
+        }[];
+    };
+    get tex(): string;
+    get variables(): string[];
+    zero(): this;
+}

package/types/algebra/polyFactor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyFactor.d.ts","sourceRoot":"","sources":["../../src/algebra/polyFactor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,UAAU,EACV,aAAa,EACb,SAAS,EACT,WAAW,EAAE,cAAc,EAE9B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAC,QAAQ,EAAC,MAAM,0BAA0B,CAAA;AACjD,OAAO,EAAC,MAAM,EAAiB,MAAM,UAAU,CAAA;AAC/C,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAKjC,qBAAa,UAAW,YAAW,aAAa,CAAC,UAAU,CAAC,EACxD,WAAW,CAAC,UAAU,CAAC,EACvB,QAAQ,CAAC,UAAU,CAAC;;gBASR,GAAG,MAAM,EAAE,CAAC,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC,EAAE;IAQ/D,KAAK,CAAC,GAAG,MAAM,EAAE,CAAC,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC,EAAE,GAAG,IAAI;IAqBvE,KAAK,IAAI,UAAU;WAuBZ,GAAG,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU;IAmB/C,GAAG,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI;IAuBzC,IAAI,OAAO,IAAI,IAAI,CAGlB;IAED,IAAI,MAAM,IAAI,IAAI,CAGjB;IAEM,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ;IAIxC,IAAI,WAAW,IAAI,MAAM,EAAE,CAE1B;IAEM,UAAU,IAAI,IAAI;IAsBlB,OAAO,IAAI,OAAO;IAWzB,IAAW,OAAO,IAAI,MAAM,CA+B3B;IAEM,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAK/B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAC,MAAM,GAAG,QAAQ,CAAC,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ;IAUtH,IAAW,OAAO,IAAI,MAAM,EAAE,CAE7B;IAED,IAAW,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAEjC;IAEM,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAMlE,SAAS,IAAI,SAAS,EAAE;IAiBxB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIpC,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IASnC,KAAK,IAAI,OAAO;IAIhB,MAAM,IAAI,OAAO;IAIjB,QAAQ,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI;IAQ9C,IAAI,SAAS,IAAI,MAAM,EAAE,CAExB;IAEM,GAAG,IAAI,IAAI;IASX,QAAQ,IAAI,IAAI;IAahB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI;IAKnC,SAAS,IAAI,UAAU;IAIvB,MAAM,IAAI,IAAI;IAgBd,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKzB,IAAI,IAAI,IAAI;IAMZ,IAAI,IAAI,IAAI;IAKZ,QAAQ,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI;IAIvC,YAAY,IAAI,cAAc,GAAG;QAAE,OAAO,EAAE;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,cAAc,CAAA;SAAC,EAAE,CAAA;KAAE;IA6FrG,IAAW,GAAG,IAAI,MAAM,CA+BvB;IAED,IAAW,SAAS,IAAI,MAAM,EAAE,CAG/B;IAMM,IAAI,IAAI,IAAI;CAMtB"}

package/types/algebra/polynom.d.ts

@@ -0,0 +1,109 @@
+import { IAlgebra, IAnalyse, IExpression, InputAlgebra, InputValue, IPiMathObject, ISolution, literalType, TABLE_OF_SIGNS } from '../pimath.interface';
+import { Fraction } from '../coefficients/fraction';
+import { Monom } from './monom';
+export type PolynomParsingType = InputValue<Polynom> | Monom;
+export interface IEuclidean {
+    quotient: Polynom;
+    reminder: Polynom;
+}
+/**
+ * Polynom class can handle polynoms, reorder, resolve, ...
+ * ```
+ * let P = new Polynom('3x-4')
+ * ```
+ */
+export declare class Polynom implements IPiMathObject<Polynom>, IExpression<Polynom>, IAnalyse<Polynom>, IAlgebra<Polynom> {
+    #private;
+    constructor(value: InputValue<Fraction>);
+    constructor(value: string);
+    constructor(value: Monom);
+    constructor(value: Polynom);
+    constructor(...values: InputValue<Fraction>[]);
+    constructor(...values: InputAlgebra<Polynom>[]);
+    /**
+     * Parse a string to a polynom.
+     * @param inputStr
+     * @param values
+     */
+    parse: (inputStr: PolynomParsingType, ...values: InputAlgebra<Monom>[]) => this;
+    /**
+     * Clone the polynom
+     */
+    clone: () => Polynom;
+    add: (...values: InputAlgebra<Polynom>[]) => Polynom;
+    commonMonom: () => Monom;
+    degree: (letter?: string) => Fraction;
+    derivative: (letter?: string) => Polynom;
+    get display(): string;
+    divide: (value: InputAlgebra<Polynom>) => Polynom;
+    empty: () => this;
+    /**
+     * Divide the current polynom by another polynom.
+     * @param P
+     * returns {quotient: Polynom, reminder: Polynom}
+     */
+    euclidean: (P: Polynom) => IEuclidean;
+    evaluate: (values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric?: boolean) => Fraction | number;
+    /**
+     * Factorize a polynom and store the best results in factors.
+     * @param letter
+     */
+    factorize: (letter?: string) => Polynom[];
+    gcdDenominator: () => number;
+    gcdNumerator: () => number;
+    getDenominators: () => number[];
+    getNumerators: () => number[];
+    getZeroes: () => ISolution[];
+    hasVariable(letter: string): boolean;
+    integrate: (a: InputValue<Fraction>, b: InputValue<Fraction>, letter?: string) => Fraction;
+    inverse(): Polynom | undefined;
+    isDeveloped: (polynomString: string) => boolean;
+    isDividableBy: (div: Polynom) => boolean;
+    isEqual: (P: Polynom) => boolean;
+    get isMultiVariable(): boolean;
+    isOne(): boolean;
+    isOppositeAt: (P: Polynom) => boolean;
+    isReduced: (polynomString: string) => boolean;
+    isSameAs: (P: Polynom) => boolean;
+    isZero(): boolean;
+    lcmDenominator: () => number;
+    lcmNumerator: () => number;
+    get length(): number;
+    letters: () => string[];
+    limitToInfinity: (letter?: string) => Fraction;
+    limitToNegativeInfinity: (letter?: string) => Fraction;
+    monomByDegree: (degree?: Fraction | number, letter?: string) => Monom;
+    monomByLetter: (letter: string) => Monom;
+    get monoms(): Monom[];
+    set monoms(M: Monom[]);
+    monomsByDegree: (degree?: number | Fraction, letter?: string) => Monom[];
+    multiply: (value: unknown) => Polynom;
+    get numberOfVars(): number;
+    one: () => this;
+    opposite: () => this;
+    get plotFunction(): string;
+    pow: (nb: number) => Polynom;
+    primitive: (letter?: string) => Polynom;
+    reduce: () => Polynom;
+    reorder: (letter?: string, revert?: boolean) => this;
+    /**
+     * Replace a variable (letter) by a polynom.
+     * @param letter
+     * @param P
+     */
+    replaceBy: (letter: string, P: Polynom) => this;
+    root(): Polynom;
+    get roots(): ISolution[];
+    set roots(value: ISolution[]);
+    sqrt(): Polynom;
+    subtract: (...values: InputAlgebra<Polynom>[]) => Polynom;
+    tableOfSigns(rootsArray?: ISolution[]): TABLE_OF_SIGNS;
+    get tex(): string;
+    get variables(): string[];
+    /**
+     * Set the polynom to zero.
+     * @returns {this}
+     */
+    zero: () => this;
+    get zeroes(): ISolution[];
+}

package/types/algebra/polynom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynom.d.ts","sourceRoot":"","sources":["../../src/algebra/polynom.ts"],"names":[],"mappings":"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"}