pimath 0.2.10 → 0.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pimath",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "A math library for teacher :)",
   "type": "module",
   "main": "dist/pimath.js",
@@ -38,24 +38,25 @@
     "url": "git+https://github.com/basilgass/PiMath.git"
   },
   "devDependencies": {
-    "@tailwindcss/vite": "^4.3.2",
+    "@tailwindcss/vite": "^4.3.3",
+    "@eslint/js": "^10.0.1",
     "@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",
+    "@vitejs/plugin-vue": "^6.0.8",
+    "autoprefixer": "^10.5.4",
+    "dependency-cruiser": "^18.1.0",
+    "eslint": "^10.8.0",
+    "globals": "^17.8.0",
+    "tailwindcss": "^4.3.3",
     "ts-loader": "^9.6.2",
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.20",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.63.0",
-    "vite": "^8.1.4",
+    "typescript-eslint": "^8.65.0",
+    "vite": "^8.2.0",
     "vitest": "^4.1.10",
-    "vue-router": "^5.1.0"
+    "vue-router": "^5.2.0"
   },
   "dependencies": {
-    "piexpression": "^0.1.3"
+    "piexpression": "^0.1.5"
   }
 }

package/src/algebra/equation.ts

@@ -9,6 +9,7 @@ import type {
 } from "../pimath.interface"
 import {Fraction} from "../coefficients"
 import {Numeric} from "../numeric"
+import {ParseError} from "../errors"
 import {EquationSolver} from "./equationSolver"
 import {Monom} from "./monom"
 import {Polynom} from "./polynom"
@@ -62,7 +63,7 @@ export class Equation implements IPiMathObject<Equation>,
         const strSign: string | false = this.#findSign(equationString)
 
         if (strSign === false) {
-            throw new Error('The equation is not valid (no sign found)')
+            throw new ParseError('The equation is not valid (no sign found)')
         }
 
         // The StrSign is found
@@ -507,7 +508,7 @@ export class Equation implements IPiMathObject<Equation>,
             return '='
         }
 
-        throw new Error('The equation is not valid (no sign found)')
+        throw new ParseError('The equation is not valid (no sign found)')
     }
 
     // -----------------------------------------------

package/src/algebra/equationSolver.ts

@@ -4,6 +4,7 @@ import {Fraction} from "../coefficients"
 import {Numeric} from "../numeric"
 import type {Equation} from "./equation"
 import {Solution} from "../analyze"
+import {MathError} from "../errors"
 
 export class EquationSolver {
     _: number
@@ -78,7 +79,7 @@ export class EquationSolver {
 
     public solveAsCardan(): Solution[] {
         if (this.#leftPolynom.degree().value !== 3) {
-            throw new Error("The equation is not cubic.")
+            throw new MathError("The equation is not cubic.")
         }
         return this.#solveCubic_CardanFormula()
     }

package/src/algebra/factor.ts

@@ -10,6 +10,7 @@ import type {
 import {Fraction} from "../coefficients/fraction"
 import {Polynom} from "./polynom"
 import {replace_in_array, splitIfOutsideParentheses, wrapParenthesis} from "../helpers"
+import {MathError, NotImplementedError} from "../errors"
 
 export class Factor implements IPiMathObject<Factor>,
     IExpression<Factor>,
@@ -42,7 +43,7 @@ export class Factor implements IPiMathObject<Factor>,
     }
 
     public parse(/*value: InputValue<Factor>*/): Factor {
-        throw new Error("Method not implemented.")
+        throw new NotImplementedError("Method not implemented.")
     }
 
     public clone(): Factor {
@@ -104,7 +105,7 @@ export class Factor implements IPiMathObject<Factor>,
     }
 
     public add(): Factor {
-        throw new Error("Adding two factors is not possible")
+        throw new MathError("Adding two factors is not possible")
     }
 
     public get asSingle(): this {
@@ -141,7 +142,7 @@ export class Factor implements IPiMathObject<Factor>,
             return this.polynom.clone().pow(this.power.value)
         }
 
-        throw new Error("The power must be a natural number")
+        throw new MathError("The power must be a natural number")
     }
 
     public divide(value: InputAlgebra<Factor | Polynom>): this {
@@ -159,7 +160,7 @@ export class Factor implements IPiMathObject<Factor>,
             return this
         }
 
-        throw new Error("The two factors must be the same")
+        throw new MathError("The two factors must be the same")
     }
 
     public evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean): number | Fraction {
@@ -241,7 +242,7 @@ export class Factor implements IPiMathObject<Factor>,
             return this
         }
 
-        throw new Error("The two factors must be the same")
+        throw new MathError("The two factors must be the same")
     }
 
     public one(): this {
@@ -251,7 +252,7 @@ export class Factor implements IPiMathObject<Factor>,
     }
 
     public opposite(): Factor {
-        throw new Error("Method not implemented.")
+        throw new NotImplementedError("Method not implemented.")
     }
 
     public get polynom(): Polynom {
@@ -276,11 +277,11 @@ export class Factor implements IPiMathObject<Factor>,
     }
 
     public primitive(): Factor {
-        throw new Error("Method not implemented.")
+        throw new NotImplementedError("Method not implemented.")
     }
 
     public reduce(): Factor {
-        throw new Error("Method not implemented.")
+        throw new NotImplementedError("Method not implemented.")
     }
 
     public root(value: number): this {
@@ -293,7 +294,7 @@ export class Factor implements IPiMathObject<Factor>,
     }
 
     public subtract(): Factor {
-        throw new Error("Subtracting two factors is not possible")
+        throw new MathError("Subtracting two factors is not possible")
     }
 
     public tableOfSigns(): TABLE_OF_SIGNS {

package/src/algebra/linearSystem.ts

@@ -5,6 +5,7 @@ import {Monom} from "./monom"
 import {Polynom} from "./polynom"
 import {Numeric} from "../numeric"
 import {Solution} from "../analyze"
+import {DimensionError, IndexError, MathError, NotImplementedError} from "../errors"
 
 export class LinearSystem implements IPiMathObject<LinearSystem>,
     IEquation<LinearSystem>,
@@ -61,7 +62,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         // Check that each row has the same number of columns
         const cols = matrix[0].length
         if (matrix.some(row => row.length !== cols)) {
-            throw new Error("All rows must have the same number of columns")
+            throw new DimensionError("All rows must have the same number of columns")
         }
 
         // Determine the default letters. The number of letters are cols-1
@@ -88,7 +89,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         if (value instanceof LinearSystem) {
             const length = value.equations.length
             if (length !== this.#equations.length) {
-                throw new Error("The number of equations must be the same")
+                throw new DimensionError("The number of equations must be the same")
             }
 
             for (let i = 0; i < length; i++) {
@@ -96,7 +97,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
             }
         } else {
             if (index === undefined || index < 0 || index >= this.#equations.length) {
-                throw new Error("Index out of range")
+                throw new IndexError("Index out of range")
             }
             const equ = new Equation(value)
             this.#equations[index].add(equ)
@@ -177,7 +178,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
     }
 
     public evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean): number | Fraction {
-        throw new Error("Method not implemented.")
+        throw new NotImplementedError("Method not implemented.")
     }
 
     public hasVariable(letter: string): boolean {
@@ -224,7 +225,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         // the value can be a number and the index of the equation to multiply
         if (Array.isArray(value)) {
             if (value.length !== this.#equations.length) {
-                throw new Error("The number of values must be the same as the number of equations")
+                throw new DimensionError("The number of values must be the same as the number of equations")
             }
 
             for (let i = 0; i < value.length; i++) {
@@ -234,7 +235,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         }
 
         if (index === undefined || index < 0 || index >= this.#equations.length) {
-            throw new Error("Index out of range")
+            throw new IndexError("Index out of range")
         }
 
         this.#equations[index].multiply(value)
@@ -280,7 +281,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
                     augmentedMatrix[i].forEach((value, index) => value.add(row_to_add[index]))
                     pivot = augmentedMatrix[i][i].clone()
                 } else {
-                    throw new Error('Unsolvable...')
+                    throw new MathError('Unsolvable...')
                 }
 
 
@@ -353,7 +354,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         if (value instanceof LinearSystem) {
             const length = value.equations.length
             if (length !== this.#equations.length) {
-                throw new Error("The number of equations must be the same")
+                throw new DimensionError("The number of equations must be the same")
             }
 
             for (let i = 0; i < length; i++) {
@@ -361,7 +362,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
             }
         } else {
             if (index === undefined || index < 0 || index >= this.#equations.length) {
-                throw new Error("Index out of range")
+                throw new IndexError("Index out of range")
             }
             const equ = new Equation(value)
             this.#equations[index].subtract(equ)

package/src/algebra/logicalset.ts

@@ -3,6 +3,7 @@
  * @module Logicalset
  */
 import {ShutingYard, ShutingyardMode} from "piexpression"
+import {ParseError} from "../errors"
 
 /**
  * Polynom class can handle polynoms, reorder, resolve, ...
@@ -26,9 +27,13 @@ export class LogicalSet {
 
     parse = (value: string): this => {
         // Parse the updated value to the shutingyard algorithm
-        this.#rpn = new ShutingYard(ShutingyardMode.SET)
-            .parse(value)
-            .rpn
+        try {
+            this.#rpn = new ShutingYard(ShutingyardMode.SET)
+                .parse(value)
+                .rpn
+        } catch (e) {
+            throw new ParseError(`Cannot parse "${value}" as a LogicalSet`, {cause: e})
+        }
 
         return this
     }

package/src/algebra/matrix.ts

@@ -2,6 +2,7 @@ import type {IExpressionMultiply, InputAlgebra, InputValue, IPiMathObject} from
 import {Polynom} from "./polynom"
 import type {Vector} from "../geometry"
 import {operation_pow} from "./operations"
+import {DimensionError, IndexError, MathError, NotImplementedError} from "../errors"
 
 export type IMatrixValues = InputAlgebra<Polynom>[][]
 
@@ -107,7 +108,7 @@ export class Matrix implements IPiMathObject<Matrix>,
 
     public add(value: Matrix): this {
         if (!this.canBeAdded(value)) {
-            throw new Error("Cannot add a matrix with different dimensions.")
+            throw new DimensionError("Cannot add a matrix with different dimensions.")
         }
         this.forEach((aij, i, j) => {
             aij.add(value.values[i][j])
@@ -195,7 +196,7 @@ export class Matrix implements IPiMathObject<Matrix>,
 
     public determinant(): Polynom {
         if (!this.isSquare()) {
-            throw new Error('Matrix is not square')
+            throw new DimensionError('Matrix is not square')
         }
 
         // Use the first line.
@@ -276,7 +277,7 @@ export class Matrix implements IPiMathObject<Matrix>,
         // Check dimensions of each rows.
         const L = values[0].length
         if (values.some(row => row.length !== L)) {
-            throw new Error("Each line must be the same length")
+            throw new DimensionError("Each line must be the same length")
         }
 
         values.forEach(row => {
@@ -298,7 +299,7 @@ export class Matrix implements IPiMathObject<Matrix>,
         // Each vectors must be the same dimension
         const L = vectors[0].dimension
         if (vectors.some(v => v.dimension !== L)) {
-            throw new Error("Each vectors must be the same dimension")
+            throw new DimensionError("Each vectors must be the same dimension")
         }
 
         this.fromDimensions(vectors[0].dimension, vectors.length)
@@ -314,7 +315,7 @@ export class Matrix implements IPiMathObject<Matrix>,
 
     public inverse(): this {
         if (!this.canBeInverted()) {
-            throw new Error('The matrix cannot be inverted.')
+            throw new MathError('The matrix cannot be inverted.')
         }
 
         const cofactors_matrix = new Matrix().fromDimensions(this.dimension.rows, this.dimension.cols)
@@ -387,7 +388,7 @@ export class Matrix implements IPiMathObject<Matrix>,
     public multiply(value: InputValue<Polynom> | Matrix): this {
         if (value instanceof Matrix) {
             if (!this.canBeMultiplied(value)) {
-                throw new Error(`Cannot multiply a matrix with incompatibles dimensions`)
+                throw new DimensionError(`Cannot multiply a matrix with incompatibles dimensions`)
             }
 
             // Multiply two matrix
@@ -455,7 +456,7 @@ export class Matrix implements IPiMathObject<Matrix>,
     }
 
     public reduce(): Matrix {
-        throw new Error('Not yet implemented')
+        throw new NotImplementedError('Not yet implemented')
     }
 
     get rows(): Polynom[][] {
@@ -466,7 +467,7 @@ export class Matrix implements IPiMathObject<Matrix>,
         const {rows, cols} = this.dimension
         if ((row < 0 || row >= rows) ||
             column < 0 || column >= cols) {
-            throw new Error(`${row}x${column} is out of range (${rows}x${cols})`)
+            throw new IndexError(`${row}x${column} is out of range (${rows}x${cols})`)
         }
 
         this.#values[row][column] = new Polynom(value)
@@ -475,7 +476,7 @@ export class Matrix implements IPiMathObject<Matrix>,
 
     public subtract(value: Matrix): this {
         if (!this.canBeAdded(value)) {
-            throw new Error("Cannot subtract a matrix with different dimensions.")
+            throw new DimensionError("Cannot subtract a matrix with different dimensions.")
         }
 
         this.forEach((aij, i, j) => {

package/src/algebra/monom.ts

@@ -14,6 +14,7 @@ import {Fraction} from "../coefficients"
 import {Numeric} from "../numeric"
 
 import {ShutingYard, ShutingyardType, type Token} from "piexpression"
+import {MathError, NotImplementedError, ParseError} from "../errors"
 
 export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse<Monom>, IAlgebra<Monom> {
     #coefficient: Fraction
@@ -165,7 +166,7 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
 
                 this.#coefficient.add(mAsMonom.coefficient)
             } else {
-                throw new Error('Add monom: ' + this.display + ' is not similar with ' +  mAsMonom.display)
+                throw new MathError('Add monom: ' + this.display + ' is not similar with ' +  mAsMonom.display)
             }
         }
         return this
@@ -650,7 +651,7 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
      */
     public root = (): this => {
         // TODO: implement nth-root for monoms
-        throw new Error('Method not implemented.')
+        throw new NotImplementedError('Method not implemented.')
     }
 
     /**
@@ -706,7 +707,7 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
 
                 this.#coefficient.add(mAsMonom.clone().coefficient.opposite())
             } else {
-                throw new Error('Subtract: Is not similar: ' + mAsMonom.display)
+                throw new MathError('Subtract: Is not similar: ' + mAsMonom.display)
             }
         }
         return this
@@ -890,7 +891,12 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
 
     #shutingYardToReducedMonom = (inputStr: string): this => {
         // Get the RPN array of the current expression
-        const SY: ShutingYard = new ShutingYard().parse(inputStr)
+        let SY: ShutingYard
+        try {
+            SY = new ShutingYard().parse(inputStr)
+        } catch (e) {
+            throw new ParseError(`Cannot parse "${inputStr}" as a Monom`, {cause: e})
+        }
         const rpn: { token: string, tokenType: ShutingyardType }[] = SY.rpn
 
         const stack: Monom[] = []

package/src/algebra/operations.ts

@@ -1,13 +1,14 @@
 import type {IExpressionMultiply, IPiMathObject} from "../pimath.interface"
+import {InvalidArgumentError} from "../errors"
 
 // TODO: create other operation_** to make things more generic !
 export function operation_pow<T extends IPiMathObject<T> & IExpressionMultiply<T>>(item: T, value: number): T {
     if (!Number.isSafeInteger(value)) {
-        throw new Error('Can only raise item by an integer')
+        throw new InvalidArgumentError('Can only raise item by an integer')
     }
 
     if (value < 0) {
-        throw new Error('Can only raise item by a positive integer')
+        throw new InvalidArgumentError('Can only raise item by a positive integer')
     }
 
     if (value === 0) {

package/src/algebra/polyFactor.ts

@@ -10,6 +10,7 @@ import type {
     TABLE_OF_SIGNS_VALUES
 } from "../pimath.interface"
 import {Fraction} from "../coefficients"
+import {MathError, NotImplementedError, ParseError} from "../errors"
 import {Factor, FACTOR_DISPLAY} from "./factor"
 import {Polynom} from "./polynom"
 import type {Solution} from "../analyze"
@@ -39,7 +40,9 @@ export class PolyFactor implements IPiMathObject<PolyFactor>,
         }
 
         values.forEach(value => {
-            if (value instanceof PolyFactor) {
+            if(typeof  value==="string"){
+                return this.fromString(value)
+            }else if (value instanceof PolyFactor) {
                 this.#factors.push(...value.factors.map(f => f.clone()))
             } else {
                 this.#factors.push(new Factor(value))
@@ -340,7 +343,7 @@ export class PolyFactor implements IPiMathObject<PolyFactor>,
 
             if (polynom.isOne()) return this
 
-            if (polynom.isZero()) throw new Error("Cannot divide by zero")
+            if (polynom.isZero()) throw new MathError("Cannot divide by zero")
             
             this.#factors.push(new Factor(polynom, -1))
         }
@@ -355,8 +358,8 @@ export class PolyFactor implements IPiMathObject<PolyFactor>,
         // - or the string has something that prevents this => use fromPolynom
 
         const [num, ...den] = splitIfOutsideParentheses(value, '/')
-        if(num==='') throw new Error('Parsing a PolyFactor from a string requires a numerator')
-        if(den.length>1) throw new Error('Parsing a PolyFactor from a string only allows max one signe "/"')
+        if(num==='') throw new ParseError('Parsing a PolyFactor from a string requires a numerator')
+        if(den.length>1) throw new ParseError('Parsing a PolyFactor from a string only allows max one signe "/"')
 
         if(den.length===0) {
             this.#factors = Factor.factorsFromString(stripParenthesis(num), true)
@@ -420,9 +423,10 @@ export class PolyFactor implements IPiMathObject<PolyFactor>,
         return this.#factors.every(f => f.isZero())
     }
 
-    public multiply(...values: PolyFactor[]): this {
+    public multiply(...values: (InputAlgebra<Polynom> | Factor |PolyFactor)[]): this {
         values.forEach(value => {
-            this.#factors = this.#factors.concat(value.clone().factors)
+            const PF = new PolyFactor( value )
+            this.#factors = this.#factors.concat(PF.factors)
         })
 
         return this
@@ -456,7 +460,7 @@ export class PolyFactor implements IPiMathObject<PolyFactor>,
     }
 
     public primitive(): PolyFactor {
-        throw new Error("Method not implemented.")
+        throw new NotImplementedError("Method not implemented.")
     }
 
     public reduce(): this {