pimath 0.2.11 → 0.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pimath",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "A math library for teacher :)",
   "type": "module",
   "main": "dist/pimath.js",
@@ -39,6 +39,7 @@
   },
   "devDependencies": {
     "@tailwindcss/vite": "^4.3.3",
+    "@eslint/js": "^10.0.1",
     "@types/eslint": "^9.6.1",
     "@vitejs/plugin-vue": "^6.0.8",
     "autoprefixer": "^10.5.4",
@@ -56,6 +57,6 @@
     "vue-router": "^5.2.0"
   },
   "dependencies": {
-    "piexpression": "^0.1.4"
+    "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"
@@ -342,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))
         }
@@ -357,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)
@@ -459,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 {

package/src/algebra/polynom.ts

@@ -2,6 +2,7 @@
  * Polynom module contains everything necessary to handle polynoms.*
  */
 import {ShutingYard, ShutingyardType, type Token} from "piexpression"
+import {InvalidArgumentError, MathError, ParseError} from "../errors"
 import type {
     IAlgebra,
     IAnalyse,
@@ -212,7 +213,7 @@ export class Polynom implements IPiMathObject<Polynom>,
             return this.divide(new Polynom(value))
         }
 
-        throw new Error(`Cannot divide by ${value as unknown as string}`)
+        throw new MathError(`Cannot divide by ${value as unknown as string}`)
     }
 
     public empty(): this {
@@ -242,7 +243,7 @@ export class Polynom implements IPiMathObject<Polynom>,
         }
 
         if (!this.degree(letter).isNatural() || !P.degree(letter).isNatural()) {
-            throw new Error('Euclidean division requires integer degrees')
+            throw new MathError('Euclidean division requires integer degrees')
         }
 
         // Get at least a letter
@@ -396,7 +397,7 @@ export class Polynom implements IPiMathObject<Polynom>,
 
     public getCoefficients(): Fraction[] {
         if (!this.degree().isNatural()) {
-            throw new Error('getCoefficients() requires a polynomial with integer degrees')
+            throw new MathError('getCoefficients() requires a polynomial with integer degrees')
         }
 
         // Assume there is only one letter.
@@ -462,8 +463,6 @@ export class Polynom implements IPiMathObject<Polynom>,
     }
 
     public isDeveloped(polynomString: string): boolean {
-        let P: Polynom
-
         // Start by removing the parenthesis after a "power"
         const pString = polynomString.replaceAll(/\^\(([-0-9/]+)\)/g, '$1')
 
@@ -473,13 +472,9 @@ export class Polynom implements IPiMathObject<Polynom>,
         }
 
 
-        // Try to build the polynom
-        try {
-            // Build the polynom
-            P = new Polynom(polynomString)
-        } catch {
-            return false
-        }
+        // Build the polynom. A malformed string throws (ParseError) instead of
+        // being silently treated as "not developed".
+        const P = new Polynom(polynomString)
 
         // Both polynom aren't the same (once developed and reduced => they cannot be equivalent)
         if (!this.isEqual(P)) {
@@ -663,13 +658,13 @@ export class Polynom implements IPiMathObject<Polynom>,
             try {
                 const k = new Fraction(value)
                 return this.#multiplyByFraction(k)
-            } catch {
-                throw new Error('Cannot multiply by this value.')
+            } catch (e) {
+                throw new MathError('Cannot multiply by this value.', {cause: e})
             }
         }
 
         // Something went wrong...
-        throw new Error(`Cannot multiply by this value: ${value as unknown as string}`)
+        throw new MathError(`Cannot multiply by this value: ${value as unknown as string}`)
     }
 
     public get numberOfVars(): number {
@@ -801,7 +796,7 @@ export class Polynom implements IPiMathObject<Polynom>,
 
                 // Add the new monom to the result polynom
                 if (pow.isStrictlyNegative()) {
-                    throw new Error(`Cannot replace variable "${letter}" with negative power in a Polynom`)
+                    throw new MathError(`Cannot replace variable "${letter}" with negative power in a Polynom`)
                 }
                 resultPolynom.add(P.clone().pow(pow.numerator).multiply(m))
             }
@@ -817,7 +812,7 @@ export class Polynom implements IPiMathObject<Polynom>,
     // ------------------------------------------
 
     public root(): Polynom {
-        throw new Error('Cannot take the root from a polynom')
+        throw new MathError('Cannot take the root from a polynom')
     }
 
     get roots(): Solution[] {
@@ -836,7 +831,7 @@ export class Polynom implements IPiMathObject<Polynom>,
     }
 
     public sqrt(): Polynom {
-        throw new Error('Cannot take the square root from a polynom')
+        throw new MathError('Cannot take the square root from a polynom')
     }
 
     public subtract(...values: InputAlgebra<Polynom>[]): this {
@@ -1085,7 +1080,7 @@ export class Polynom implements IPiMathObject<Polynom>,
                 const letters = inputStr.split('')
 
                 if (fractions.length > letters.length + 1) {
-                    throw new Error(`Too many values: ${letters.length} letters but ${fractions.length} values provided`)
+                    throw new InvalidArgumentError(`Too many values: ${letters.length} letters but ${fractions.length} values provided`)
                 }
 
                 let i = 0
@@ -1127,7 +1122,7 @@ export class Polynom implements IPiMathObject<Polynom>,
                 break
 
             case ShutingyardType.CONSTANT:
-                throw new Error('Unsupported CONSTANT token in Polynom parser')
+                throw new ParseError('Unsupported CONSTANT token in Polynom parser')
 
             case ShutingyardType.OPERATION:
                 if (stack.length >= 2) {
@@ -1136,7 +1131,7 @@ export class Polynom implements IPiMathObject<Polynom>,
 
                     // Check if the polynoms are not undefined.
                     if (a === undefined || b === undefined) {
-                        throw new Error('Unexpected undefined operand in Polynom parser stack')
+                        throw new ParseError('Unexpected undefined operand in Polynom parser stack')
                     }
 
                     if (element.token === '+') {
@@ -1147,16 +1142,16 @@ export class Polynom implements IPiMathObject<Polynom>,
                         stack.push(a.multiply(b))
                     } else if (element.token === '/') {
                         if (b.degree().isStrictlyPositive()) {
-                            throw new Error('Cannot divide a Polynom by another Polynom of degree > 0')
+                            throw new MathError('Cannot divide a Polynom by another Polynom of degree > 0')
                         } else {
                             // a.divide(b.monoms[0].coefficient)
                             stack.push(a.divide(b.monoms[0].coefficient))
                         }
                     } else if (element.token === '^') {
                         if (b.degree().isStrictlyPositive()) {
-                            throw new Error('Cannot elevate a polynom with another polynom !')
-                        } else if (b.monoms[0].coefficient.isRelative())
-                            // Integer power
+                            throw new MathError('Cannot elevate a polynom with another polynom !')
+                        } else if (b.monoms[0].coefficient.isNatural())
+                            // Natural (positive) power
                         {
                             stack.push(a.pow(b.monoms[0].coefficient.value))
                         } else {
@@ -1168,7 +1163,7 @@ export class Polynom implements IPiMathObject<Polynom>,
 
                                 stack.push(a)
                             } else {
-                                throw new Error('Cannot raise a multi-monom Polynom to a fractional power')
+                                throw new MathError('Cannot raise a multi-monom Polynom to a fractional power')
                             }
                         }
                     }
@@ -1179,7 +1174,7 @@ export class Polynom implements IPiMathObject<Polynom>,
                         stack.push(a.opposite())
                     }
                 } else {
-                    throw new Error("Error parsing the polynom")
+                    throw new ParseError("Error parsing the polynom")
                 }
 
 
@@ -1187,11 +1182,11 @@ export class Polynom implements IPiMathObject<Polynom>,
 
             case ShutingyardType.MONOM:
                 // Should never appear.
-                throw new Error('Unexpected MONOM token in polynom parser')
+                throw new ParseError('Unexpected MONOM token in polynom parser')
 
             case ShutingyardType.FUNCTION:
                 // Should never appear.
-                throw new Error(`Unsupported function token "${element.token}" in polynom parser`)
+                throw new ParseError(`Unsupported function token "${element.token}" in polynom parser`)
         }
 
 
@@ -1203,7 +1198,12 @@ export class Polynom implements IPiMathObject<Polynom>,
      */
     #shutingYardToReducedPolynom(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 Polynom`, {cause: e})
+        }
         const rpn: { token: string, tokenType: ShutingyardType }[] = SY.rpn
 
         // New version for reducing shuting yard.