pimath 0.0.133 → 0.1.0

package/package.json

@@ -1,19 +1,32 @@
 {
   "name": "pimath",
-  "version": "0.0.133",
+  "version": "0.1.0",
   "description": "A math library for teacher :)",
   "type": "module",
-  "main": "dist/pimath.js",
-  "types": "dist/pimath.d.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/pimath.js",
+      "require": "./dist/pimath.js"
+    },
+    "./types": {
+      "import": "./types/index.d.ts",
+      "require": "./types/index.d.ts"
+    }
+  },
   "files": [
-    "dist"
+    "dist",
+    "types"
   ],
   "scripts": {
-    "test": "mocha -r ts-node/register 'tests/**/*.test.ts'",
+    "test": "vitest",
     "dev": "vite serve",
     "build": "tsc --p ./tsconfig-build.json && vite build",
     "preview": "vite preview",
-    "docs": "typedoc"
+    "docs": "typedoc",
+    "dependency-cruise": "dependency-cruise -T dot -x node_modules -v -- src/index.ts  | dot -T svg > dependencies.svg"
   },
   "keywords": [
     "math",
@@ -22,19 +35,24 @@
   "author": "Basil Gass",
   "license": "MIT",
   "devDependencies": {
-    "@types/chai": "*",
-    "@types/mocha": "*",
-    "@types/node": "^20.8.2",
-    "@typescript-eslint/eslint-plugin": "^6.7.4",
-    "@typescript-eslint/parser": "^6.7.4",
-    "chai": "*",
-    "eslint": "^8.50.0",
-    "mocha": "*",
-    "ts-loader": "^9.4.4",
-    "ts-node": "^10.9.1",
-    "typedoc": "^0.25.1",
-    "typescript": "^5.2.2",
-    "vite": "^5.2.10",
-    "vite-plugin-dts": "^3.9.0"
+    "@eslint/js": "^9.4.0",
+    "@types/eslint__js": "^8.42.3",
+    "autoprefixer": "^10.4.19",
+    "dependency-cruiser": "^16.3.10",
+    "eslint": "^8.57.0",
+    "globals": "^15.3.0",
+    "postcss": "^8.4.38",
+    "tailwindcss": "^3.4.3",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.25.13",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.12.0",
+    "vite": "^5.2.12",
+    "vite-plugin-dts": "^3.9.1",
+    "vitest": "^1.6.0"
+  },
+  "dependencies": {
+    "piexpression": "^0.0.8"
   }
 }

package/types/algebra/equation.d.ts

@@ -0,0 +1,102 @@
+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,10 @@
+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,EAAc,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGxC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAE1C,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;CAkUtC"}

package/types/algebra/factor.d.ts

@@ -0,0 +1,46 @@
+import { IAlgebra, IExpression, InputAlgebra, InputValue, IPiMathObject, literalType } 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;
+}
+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,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtH,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;CAMtB;AAED,oBAAY,cAAc;IACtB,IAAI,IAAA;IACJ,KAAK,IAAA;CACR"}

package/types/algebra/linearSystem.d.ts

@@ -0,0 +1,37 @@
+import { IAlgebra, IEquation, InputValue, IPiMathObject, ISolution, literalType } from '../pimath.interface';
+import { Fraction } from '../coefficients/fraction';
+import { Equation } from './equation';
+import { Polynom } from './polynom';
+
+/**
+ * Linear system of equations
+ * @class LinearSystem
+ */
+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;AASjC,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/{dist/maths → types}/algebra/monom.d.ts

@@ -1,207 +1,169 @@
+import { IAlgebra, IAnalyse, IExpression, InputAlgebra, InputValue, IPiMathObject, literalType } from '../pimath.interface';
 import { Fraction } from '../coefficients/fraction';
-import { Token } from '../shutingyard.ts';
 
-export type literalType = {
-    [Key: string]: Fraction;
-};
-export declare class Monom {
-    private _coefficient;
-    private _literal;
+export declare class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse<Monom>, IAlgebra<Monom> {
+    #private;
+    constructor(value?: InputValue<Fraction>);
+    constructor(value?: Monom);
     /**
-     * Create a Monom
-     * Defined as \\(k \\cdot x^{n}\\), where \\( k,n \in \\mathbb{Q}\\).
-     * Examples: \\(3x^2\\) or \\(3/5x^2\\)
-     * @param value (optional) string The value that should be parse. Can be a Monom, a Fraction, a string or a number. If nothing is provided, it will return the trivial monom (0).
+     * Parse a string to a monom. The string may include fraction.
+     * @param inputStr
      */
-    constructor(value?: unknown);
+    parse(inputStr: InputAlgebra<Monom>): this;
     /**
-     * Get the coefficient \\(k\\) of the Monom \\(k\\cdot x^{n}\\)
-     * @returns {Fraction}
+     * Clone the current Monom.
      */
-    get coefficient(): Fraction;
+    clone: () => Monom;
+    static gcd: (...monoms: Monom[]) => Monom;
     /**
-     * Set the coefficient \\(k\\) value of the monom
-     * @param {Fraction | number | string} F
+     * Multiply two monoms and return a NEW monom.
+     * @param monoms
      */
-    set coefficient(F: Fraction | number | string);
+    static xMultiply: (...monoms: Monom[]) => Monom;
     /**
-     * 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}
+     * Add all similar monoms. If they aren't similar, they are simply skipped.
+     * @param M (Monom[]) The monoms to add.
      */
-    get literal(): literalType;
+    add: (...M: InputAlgebra<Fraction>[]) => this;
     /**
-     * Set the literal part of the monom. Must be a dictionary {x: Fraction, y: Fraction, ...}
-     * @param {literalType} L
+     * Get the coefficient \\(k\\) of the Monom \\(k\\cdot x^{n}\\)
+     * @returns {Fraction}
      */
-    set literal(L: literalType);
+    get coefficient(): Fraction;
     /**
-     * Get the literal square roots of the Monom.
-     * TODO: remove this getter ? Is it used and is it correct ?
-     * @returns {literalType}
+     * Set the coefficient \\(k\\) value of the monom
+     * @param {Fraction | number | string} F
      */
-    get literalSqrt(): literalType;
+    set coefficient(F: InputValue<Fraction>);
+    containsRationalPower: () => boolean;
     /**
-     * Set the literal part of the monom from a string
-     * @param inputStr  String like x^2y^3
+     * 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)
      */
-    set literalStr(inputStr: string);
+    degree: (letter?: string) => Fraction;
     /**
-     * Get the variables letters
+     * Derivative the monom
+     * @param letter
      */
-    get variables(): string[];
+    derivative: (letter?: string) => Monom;
     /**
      * This display getter is to be used in the polynom display getter
      */
     get display(): string;
-    get dividers(): Monom[];
-    /**
-     * Display the monom, forcing the '+' sign to appear
-     */
-    get displayWithSign(): string;
-    get texWithSign(): string;
-    get plotFunction(): string;
     /**
-     * Get the tex output of the monom
+     * Divide the current monoms by multiple monoms
+     * @param M (Monom[])
      */
-    get tex(): string;
+    divide: (...M: InputAlgebra<Fraction>[]) => this;
+    get dividers(): Monom[];
     /**
-     * Get the least common multiple of monoms
-     * @param monoms    Array of monoms
+     * Evaluate a monom. Each setLetter must be assigned to a Fraction.
+     * @param values    Dictionary of <setLetter: Fraction>
+     * @param asNumeric
      */
-    static lcm: (...monoms: Monom[]) => Monom;
+    evaluate: (values: literalType<number | Fraction> | InputValue<Fraction>, asNumeric?: boolean) => Fraction | number;
     /**
-     * Multiply two monoms and return a NEW monom.
-     * @param monoms
+     * Determine if a monom contains a setLetter in it's literal part
+     * @param letter
      */
-    static xmultiply: (...monoms: Monom[]) => Monom;
+    hasVariable: (letter?: string) => boolean;
+    integrate(a: InputValue<Fraction>, b: InputValue<Fraction>, letter?: string | undefined): Fraction;
+    inverse: () => this;
+    isDivisible: (div: Monom) => boolean;
     /**
-     * Parse a string to a monom. The string may include fraction.
-     * @param inputStr
+     * Determine if two monoms are equals
+     * @param M
      */
-    parse: (inputStr: unknown) => Monom;
-    addToken: (stack: Monom[], element: Token) => void;
+    isEqual: (M: Monom) => boolean;
+    isLiteralSquare: () => boolean;
     /**
-     * Clone the current Monom.
+     * Determine if the monom is one
      */
-    clone: () => Monom;
-    copyLiterals: (literal: literalType) => literalType;
-    makeSame: (M: Monom) => Monom;
+    isOne: () => boolean;
     /**
-     * Create a zero value monom
+     * Determine if two monoms are similar
+     * @param M
      */
-    zero: () => Monom;
+    isSameAs: (M: Monom) => boolean;
+    isSquare: () => boolean;
     /**
-     * Create a one value monom
+     * Determine if the monom is null
      */
-    one: () => Monom;
+    isZero: () => boolean;
     /**
-     * Clean the monom by removing each letters with a power of zero.
+     * 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}
      */
-    clean: () => Monom;
-    reduce: () => Monom;
+    get literal(): literalType<Fraction>;
     /**
-     * Get the opposed
-     * Returns a monom.
+     * Set the literal part of the monom. Must be a dictionary {x: Fraction, y: Fraction, ...}
+     * @param {literalType<Fraction>} L
      */
-    opposed: () => Monom;
+    set literal(L: literalType<Fraction>);
     /**
-     * Add all similar monoms. If they aren't similar, they are simply skipped.
-     * @param M (Monom[]) The monoms to add.
+     * Get the literal square roots of the Monom.
+     * TODO: remove this getter ? Is it used and is it correct ?
+     * @returns {literalType<Fraction>}
      */
-    add: (...M: Monom[]) => Monom;
+    get literalSqrt(): literalType<Fraction>;
     /**
-     * Subtract multiple monoms
-     * @param M (Monom[]) The monoms to subtract
+     * Set the literal part of the monom from a string
+     * @param inputStr  String like x^2y^3
      */
-    subtract: (...M: Monom[]) => Monom;
+    set literalStr(inputStr: string);
     /**
      * Multiple multiple monoms to the current monom
      * @param M (Monom[]) The monoms to multiply to.
      */
-    multiply: (...M: Monom[]) => Monom;
-    multiplyByNumber: (F: Fraction | number) => Monom;
+    multiply: (...M: InputAlgebra<Fraction>[]) => this;
     /**
-     * Divide the current monoms by multiple monoms
-     * @param M (Monom[])
+     * Create a one value monom
      */
-    divide: (...M: Monom[]) => 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) => Monom;
+    pow: (nb: number | Fraction) => this;
+    primitive: (letter?: string) => Monom;
+    reduce: () => this;
+    removeVariable(letter: string): void;
     /**
      * Get the nth-root of the monom
-     * @param p
-     */
-    root: (p: number) => Monom;
-    /**
-     * Return the square root of a monom
-     */
-    sqrt: () => Monom;
-    compare: (M: Monom, sign?: string) => boolean;
-    /**
-     * Determine if the monom is null
-     */
-    isZero(): boolean;
-    /**
-     * Determine if the monom is one
-     */
-    isOne(): boolean;
-    /**
-     * Determine if two monoms are equals
-     * @param M
      */
-    isEqual: (M: Monom) => boolean;
-    /**
-     * Determine if two monoms are similar
-     * @param M
-     */
-    isSameAs: (M: Monom) => boolean;
-    isSquare: () => boolean;
-    isLiteralSquare: () => boolean;
-    hasFractionCoefficient: () => boolean;
-    /**
-     * Determine if a monom contains a setLetter in it's literal part
-     * @param letter
-     */
-    hasLetter: (letter?: string) => boolean;
+    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: Fraction | number) => void;
+    setLetter: (letter: string, pow: InputValue<Fraction>) => this;
     /**
-     * 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)
+     * Return the square root of a monom
      */
-    degree: (letter?: string) => Fraction;
+    sqrt: () => this;
     /**
-     * Evaluate a monom. Each setLetter must be assigned to a Fraction.
-     * @param values    Dictionary of <setLetter: Fraction>
+     * Subtract multiple monoms
+     * @param M (Monom[]) The monoms to subtract
      */
-    evaluate: (values: literalType | Fraction | number) => Fraction;
-    evaluateAsNumeric: (values: number | {
-        [Key: string]: number;
-    }) => number;
+    subtract: (...M: InputAlgebra<Fraction>[]) => this;
     /**
-     * Derivative the monom
-     * @param letter
+     * Get the tex output of the monom
      */
-    derivative: (letter?: string) => Monom;
-    primitive: (letter?: string) => Monom;
+    get tex(): string;
     /**
-     * Determine if multiple monoms are similar
-     * @param M
+     * Get the variables letters
      */
-    areSameAs: (...M: Monom[]) => boolean;
+    get variables(): string[];
     /**
-     * Determine if multiple monoms are equals
-     * @param M
+     * Create a zero value monom
      */
-    areEquals: (...M: Monom[]) => boolean;
-    isDivisible: (div: Monom) => boolean;
+    zero: () => this;
     private _getLiteralDividers;
-    private _shutingYardToReducedMonom;
 }

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,43 @@
+import { IAlgebra, IExpression, InputAlgebra, InputValue, IPiMathObject, literalType } 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;
+    add(...values: PolyFactor[]): this;
+    degree(letter?: string): Fraction;
+    derivative(): this;
+    develop(): Polynom;
+    divide(value: PolyFactor): this;
+    evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean): number | Fraction;
+    hasVariable(letter: string): boolean;
+    inverse(): this;
+    isEqual(value: PolyFactor): boolean;
+    isOne(): boolean;
+    isZero(): boolean;
+    multiply(...values: PolyFactor[]): this;
+    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;
+    zero(): this;
+    static gcd(...values: PolyFactor[]): PolyFactor;
+    get factors(): Factor[];
+    set factors(value: Factor[]);
+    get variables(): string[];
+    get asRoot(): this;
+    get asPower(): this;
+    get numerator(): Factor[];
+    get denominator(): Factor[];
+    get display(): string;
+    get tex(): string;
+}