pimath 0.2.8 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pimath",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "A math library for teacher :)",
   "type": "module",
   "main": "dist/pimath.js",
@@ -38,22 +38,22 @@
     "url": "git+https://github.com/basilgass/PiMath.git"
   },
   "devDependencies": {
-    "@tailwindcss/vite": "^4.1.18",
-    "@vitejs/plugin-vue": "^6.0.4",
-    "autoprefixer": "^10.4.24",
-    "dependency-cruiser": "^17.3.8",
-    "eslint": "^9.39.2",
-    "globals": "^17.3.0",
-    "tailwindcss": "^4.1.18",
-    "ts-loader": "^9.5.4",
+    "@tailwindcss/vite": "^4.3.2",
+    "@types/eslint": "^9.6.1",
+    "@vitejs/plugin-vue": "^6.0.7",
+    "autoprefixer": "^10.5.2",
+    "dependency-cruiser": "^18.0.0",
+    "eslint": "^10.6.0",
+    "globals": "^17.7.0",
+    "tailwindcss": "^4.3.2",
+    "ts-loader": "^9.6.2",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.28.16",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.54.0",
-    "vite": "^7.3.1",
-    "vite-plugin-dts": "^4.5.4",
-    "vitest": "^4.0.18",
-    "vue-router": "^5.0.2"
+    "typedoc": "^0.28.20",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.63.0",
+    "vite": "^8.1.4",
+    "vitest": "^4.1.10",
+    "vue-router": "^5.1.0"
   },
   "dependencies": {
     "piexpression": "^0.1.3"

package/src/algebra/equation.ts

@@ -7,15 +7,14 @@ import type {
     IPiMathObject,
     literalType
 } from "../pimath.interface"
-import {Fraction} from "../coefficients/fraction"
+import {Fraction} from "../coefficients"
 import {Numeric} from "../numeric"
 import {EquationSolver} from "./equationSolver"
 import {Monom} from "./monom"
 import {Polynom} from "./polynom"
-import type {Solution} from "../analyze/solution"
+import type {Solution} from "../analyze"
 
-export class Equation implements
-    IPiMathObject<Equation>,
+export class Equation implements IPiMathObject<Equation>,
     IEquation<Equation>,
     IAlgebra<Equation> {
 
@@ -96,15 +95,15 @@ export class Equation implements
     }
 
     public static makeSolutionsUnique(solutions: Solution[], sorted?: boolean): Solution[] {
-        const solutionAsTex: string[] = [],
-            uniqueSolutions = solutions.filter(sol => {
-                if (!solutionAsTex.includes(sol.tex)) {
-                    solutionAsTex.push(sol.tex)
-                    return true
-                } else {
-                    return false
-                }
-            })
+        const solutionAsTex: string[] = []
+        const uniqueSolutions = solutions.filter(sol => {
+            if (!solutionAsTex.includes(sol.tex)) {
+                solutionAsTex.push(sol.tex)
+                return true
+            } else {
+                return false
+            }
+        })
 
         if (sorted === true) {
             uniqueSolutions.sort((a, b) => a.value - b.value)
@@ -191,13 +190,13 @@ export class Equation implements
      * @param values
      * @param asNumeric
      */
-    public evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean  ): boolean {
+    public evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric: boolean): boolean {
         // Evaluate the left and right part of the equation.
         // compare the results.
 
         // Evaluate the left and right part of the equation.
-        const left = this.#left.evaluate(values, asNumeric),
-            right = this.#right.evaluate(values, asNumeric)
+        const left = this.#left.evaluate(values, asNumeric)
+        const right = this.#right.evaluate(values, asNumeric)
 
         // compare the results.
         if (asNumeric) {
@@ -227,8 +226,8 @@ export class Equation implements
 
     // Equations helpers
     public isEqualTo = (equ: Equation): boolean => {
-        const p1 = equ.clone().moveLeft().left,
-            p2 = this.clone().moveLeft().left
+        const p1 = equ.clone().moveLeft().left
+        const p2 = this.clone().moveLeft().left
 
         // They are the same.
         return p1.isEqual(p2) || p1.isOppositeAt(p2)
@@ -236,8 +235,8 @@ export class Equation implements
 
     public isLinearTo = (equ: Equation): boolean => {
         // Move all left.
-        const p1 = equ.clone().moveLeft().simplify().left,
-            p2 = this.clone().moveLeft().simplify().left
+        const p1 = equ.clone().moveLeft().simplify().left
+        const p2 = this.clone().moveLeft().simplify().left
 
         // They are the same.
         return p1.isEqual(p2) || p1.isOppositeAt(p2)
@@ -427,7 +426,7 @@ export class Equation implements
         // Set the sign value as formatted.
         this.#sign = this.#formatSign(value)
     }
-
+    
     public get signAsTex(): string {
         if (this.#sign === '>=') {
             return '\\geq'
@@ -480,7 +479,7 @@ export class Equation implements
     }
 
     public test = (values: literalType<Fraction>): boolean => {
-        return (this.left.evaluate(values) as Fraction).isEqual(this.right.evaluate(values))
+        return (this.left.evaluate(values)).isEqual(this.right.evaluate(values))
     }
 
     public get variables(): string[] {

package/src/algebra/polynom.ts

@@ -136,7 +136,7 @@ export class Polynom implements IPiMathObject<Polynom>,
 
         for (const value of values) {
             if (value instanceof Polynom) {
-                this.#monoms = this.#monoms.concat(value.monoms.map(m=>m.clone()))
+                this.#monoms = this.#monoms.concat(value.monoms.map(m => m.clone()))
             } else if (value instanceof Monom) {
                 this.#monoms.push(value.clone())
             } else if (typeof value === "number" && Number.isSafeInteger(value)) {
@@ -279,8 +279,11 @@ export class Polynom implements IPiMathObject<Polynom>,
         return {quotient, reminder}
     }
 
+    public evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric: true): number
+    public evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric?: false): Fraction
+    public evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric?: boolean): Fraction | number
     public evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric?: boolean): Fraction | number {
-        // Return the numeric value, without using Fraction
+        // Return the numeric value without using Fraction
         if (asNumeric) {
             return this.#evaluateAsNumeric(values)
         }
@@ -304,7 +307,7 @@ export class Polynom implements IPiMathObject<Polynom>,
         this.#factors = []
 
         // There is only one monom - it's already considered as factor.
-        if(this.monoms.length===1) return [this.clone()]
+        if (this.monoms.length === 1) return [this.clone()]
 
         let P = this.clone().reorder()
 
@@ -400,7 +403,7 @@ export class Polynom implements IPiMathObject<Polynom>,
         const orderedPolynom = this.clone().reorder()
 
         const length = this.degree().value + 1
-        const coeffs = Array.from({length}, ()=>new Fraction(0))
+        const coeffs = Array.from({length}, () => new Fraction(0))
 
         orderedPolynom.monoms.forEach(monom => {
             const index = length - monom.degree().value - 1
@@ -445,13 +448,13 @@ export class Polynom implements IPiMathObject<Polynom>,
     public integrate(a: InputValue<Fraction>, b: InputValue<Fraction>, letter = 'x'): Fraction {
         const primitive = this.primitive(letter)
 
-        const valuesA: literalType<Fraction> = {},
-            valuesB: literalType<Fraction> = {}
+        const valuesA: literalType<Fraction> = {}
+        const valuesB: literalType<Fraction> = {}
 
         valuesA[letter] = new Fraction(a)
         valuesB[letter] = new Fraction(b)
 
-        return (primitive.evaluate(valuesB) as Fraction).subtract(primitive.evaluate(valuesA))
+        return (primitive.evaluate(valuesB)).subtract(primitive.evaluate(valuesA))
     }
 
     public inverse(): Polynom | undefined {
@@ -494,7 +497,7 @@ export class Polynom implements IPiMathObject<Polynom>,
             const zero = div.getZeroes()[0]
 
             if (zero.exact) {
-                return (this.evaluate(zero.fraction) as Fraction).isZero()
+                return (this.evaluate(zero.fraction)).isZero()
             } else {
                 return false
             }
@@ -548,7 +551,7 @@ export class Polynom implements IPiMathObject<Polynom>,
         // Finite value: evaluate directly
         if (f.isFinite()) {
             const l = letter ?? this.variables[0] ?? 'x'
-            return this.evaluate({[l]: f}) as Fraction
+            return this.evaluate({[l]: f})
         }
 
         const M = this.monomByDegree(undefined, letter)
@@ -747,8 +750,8 @@ export class Polynom implements IPiMathObject<Polynom>,
     public reorder(letter = 'x', revert = false): this {
         const otherLetters = this.variables.filter(x => x !== letter)
         this.#monoms.sort(function (a, b) {
-            const da = a.degree(letter).value,
-                db = b.degree(letter).value
+            const da = a.degree(letter).value
+            const db = b.degree(letter).value
 
             // Values are different
             if (da !== db) {
@@ -758,8 +761,8 @@ export class Polynom implements IPiMathObject<Polynom>,
             // if values are equals, check other letters - it must be reverted in that case !
             if (otherLetters.length > 0) {
                 for (const L of otherLetters) {
-                    const da = a.degree(L).value,
-                        db = b.degree(L).value
+                    const da = a.degree(L).value
+                    const db = b.degree(L).value
 
                     // Values are different
                     if (da !== db) {
@@ -889,7 +892,7 @@ export class Polynom implements IPiMathObject<Polynom>,
             ]
 
             testingRoots.forEach((test, index) => {
-                const sign = this.evaluate({[this.variables[0] ?? 'x']: test}, true) as number
+                const sign = this.evaluate({[this.variables[0] ?? 'x']: test}, true)
                 signs[index * 2] = sign > 0 ? '+' : '-'
             })
         }
@@ -1128,8 +1131,8 @@ export class Polynom implements IPiMathObject<Polynom>,
 
             case ShutingyardType.OPERATION:
                 if (stack.length >= 2) {
-                    const b = stack.pop(),
-                        a = stack.pop()
+                    const b = stack.pop()
+                    const a = stack.pop()
 
                     // Check if the polynoms are not undefined.
                     if (a === undefined || b === undefined) {

package/types/algebra/equation.d.ts

@@ -1,7 +1,7 @@
-import { EQUATION_SIGN, IAlgebra, IEquation, InputAlgebra, InputValue, IPiMathObject, literalType } from '../pimath.interface';
-import { Fraction } from '../coefficients/fraction';
-import { Polynom } from './polynom';
-import { Solution } from '../analyze/solution';
+import type { EQUATION_SIGN, IAlgebra, IEquation, InputAlgebra, InputValue, IPiMathObject, literalType } from "../pimath.interface";
+import { Fraction } from "../coefficients";
+import { Polynom } from "./polynom";
+import type { Solution } from "../analyze";
 export declare class Equation implements IPiMathObject<Equation>, IEquation<Equation>, IAlgebra<Equation> {
     #private;
     constructor(equation: InputAlgebra<Polynom> | Equation);
@@ -12,71 +12,21 @@ export declare class Equation implements IPiMathObject<Equation>, IEquation<Equa
     get display(): string;
     static isEquationString(equationString: string): boolean;
     static makeSolutionsUnique(solutions: Solution[], sorted?: boolean): Solution[];
-    /**
-     * 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;
     create: (left: Polynom, right: Polynom, sign?: string) => 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): boolean;
-    /**
-     * Determine if the equation contains a variable.
-     * @param letter
-     */
+    evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric: boolean): boolean;
     hasVariable: (letter: string) => boolean;
     isEqual(value: InputValue<Equation>): boolean;
     isEqualTo: (equ: Equation) => boolean;
     isLinearTo: (equ: Equation) => boolean;
-    /**
-     * Determine if the equation contains more than one letter/variable.
-     */
     isMultiVariable: () => boolean;
-    /**
-     * Reorder the polynom to have only one letter on the left, the rest on the right.
-     * @param letter
-     */
     isolate: (letter?: string) => this | false;
     get left(): Polynom;
     set left(value: Polynom);
     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;
     get numberOfVars(): number;
     opposite: () => this;
@@ -89,9 +39,6 @@ export declare class Equation implements IPiMathObject<Equation>, IEquation<Equa
     get sign(): string;
     set sign(value: string);
     get signAsTex(): string;
-    /**
-     * Multiply by the lcm denominator and divide by the gcm numerators.
-     */
     simplify: () => this;
     solve: () => Solution[];
     split(): [Polynom, Polynom];
@@ -99,3 +46,4 @@ export declare class Equation implements IPiMathObject<Equation>, IEquation<Equa
     test: (values: literalType<Fraction>) => boolean;
     get variables(): string[];
 }
+//# sourceMappingURL=equation.d.ts.map

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

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

package/types/algebra/equationSolver.d.ts

@@ -1,6 +1,6 @@
-import { Polynom } from './polynom';
-import { Equation } from './equation';
-import { Solution } from '../analyze';
+import type { Polynom } from "./polynom";
+import type { Equation } from "./equation";
+import { Solution } from "../analyze";
 export declare class EquationSolver {
     #private;
     _: number;
@@ -11,3 +11,4 @@ export declare class EquationSolver {
     solve(): Solution[];
     solveAsCardan(): Solution[];
 }
+//# sourceMappingURL=equationSolver.d.ts.map

package/types/algebra/factor.d.ts

@@ -1,6 +1,6 @@
-import { IAlgebra, IExpression, InputAlgebra, InputValue, IPiMathObject, literalType, TABLE_OF_SIGNS } from '../pimath.interface';
-import { Fraction } from '../coefficients/fraction';
-import { Polynom } from './polynom';
+import type { IAlgebra, IExpression, InputAlgebra, InputValue, IPiMathObject, 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>);
@@ -47,3 +47,4 @@ export declare enum FACTOR_DISPLAY {
     ROOT = 0,
     POWER = 1
 }
+//# sourceMappingURL=factor.d.ts.map

package/types/algebra/index.d.ts

@@ -7,3 +7,4 @@ export * from './monom';
 export * from './polyFactor';
 export * from './polynom';
 export * from './matrix';
+//# sourceMappingURL=index.d.ts.map

package/types/algebra/linearSystem.d.ts

@@ -1,8 +1,8 @@
-import { IAlgebra, IEquation, InputValue, IPiMathObject, literalType } from '../pimath.interface';
-import { Fraction } from '../coefficients';
-import { Equation } from './equation';
-import { Polynom } from './polynom';
-import { Solution } from '../analyze';
+import type { IAlgebra, IEquation, InputValue, IPiMathObject, literalType } from "../pimath.interface";
+import { Fraction } from "../coefficients";
+import { Equation } from "./equation";
+import { Polynom } from "./polynom";
+import { Solution } from "../analyze";
 export declare class LinearSystem implements IPiMathObject<LinearSystem>, IEquation<LinearSystem>, IAlgebra<LinearSystem> {
     #private;
     constructor(...values: (string | Equation)[]);
@@ -48,3 +48,4 @@ export declare class LinearSystem implements IPiMathObject<LinearSystem>, IEquat
     get variables(): string[];
     set variables(value: string | string[]);
 }
+//# sourceMappingURL=linearSystem.d.ts.map

package/types/algebra/logicalset.d.ts

@@ -1,12 +1,5 @@
-/**
- * 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;
     get tex(): string;
@@ -19,3 +12,4 @@ export declare class LogicalSet {
     vennAB(): string[];
     vennABC(): string[];
 }
+//# sourceMappingURL=logicalset.d.ts.map

package/types/algebra/matrix.d.ts

@@ -1,6 +1,6 @@
-import { IExpressionMultiply, InputAlgebra, InputValue, IPiMathObject } from '../pimath.interface';
-import { Polynom } from './polynom';
-import { Vector } from '../geometry';
+import type { IExpressionMultiply, InputAlgebra, InputValue, IPiMathObject } from "../pimath.interface";
+import { Polynom } from "./polynom";
+import type { Vector } from "../geometry";
 export type IMatrixValues = InputAlgebra<Polynom>[][];
 export declare class Matrix implements IPiMathObject<Matrix>, IExpressionMultiply<Matrix> {
     #private;
@@ -49,3 +49,4 @@ export declare class Matrix implements IPiMathObject<Matrix>, IExpressionMultipl
     get values(): Polynom[][];
     zero(): this;
 }
+//# sourceMappingURL=matrix.d.ts.map

package/types/algebra/monom.d.ts

@@ -1,162 +1,50 @@
-import { IAlgebra, IAnalyse, IExpression, InputAlgebra, InputValue, IPiMathObject, literalType } from '../pimath.interface';
-import { Fraction } from '../coefficients';
+import type { IAlgebra, IAnalyse, IExpression, InputAlgebra, InputValue, IPiMathObject, literalType } from "../pimath.interface";
+import { Fraction } from "../coefficients";
 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;
-    /**
-     * Get the tex output of the monom
-     */
     get tex(): string;
-    /**
-     * This display getter is to be used in the polynom display getter
-     */
     get display(): string;
     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;
-    /**
-     * 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): 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>);
-    /**
-     * 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
-     * @todo Not yet implemented
-     */
     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 variables letters
-     */
     get variables(): string[];
-    /**
-     * Create a zero value monom
-     */
     zero: () => this;
 }
+//# sourceMappingURL=monom.d.ts.map

package/types/algebra/operations.d.ts

@@ -1,2 +1,3 @@
-import { IExpressionMultiply, IPiMathObject } from '../pimath.interface';
+import type { IExpressionMultiply, IPiMathObject } from "../pimath.interface";
 export declare function operation_pow<T extends IPiMathObject<T> & IExpressionMultiply<T>>(item: T, value: number): T;
+//# sourceMappingURL=operations.d.ts.map