pimath 0.2.10 → 0.2.12

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.

package/src/coefficients/fraction.ts

@@ -1,5 +1,6 @@
 import type {compareSign, IExpression, InputValue, IPiMathObject} from "../pimath.interface"
 import {Numeric} from "../numeric"
+import {InvalidArgumentError, MathError} from "../errors"
 
 export enum FRAC_TYPE {
     frac = 'frac',
@@ -263,7 +264,7 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
 
     public amplify = (k: number): this => {
         if (!Number.isSafeInteger(k)) {
-            throw new Error("The amplification factor must be a safe integer.")
+            throw new InvalidArgumentError("The amplification factor must be a safe integer.")
         }
 
         this.#numerator *= k
@@ -405,11 +406,11 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         const p: number = decimal ? decimal.length : 0
 
         if (!Number.isSafeInteger(length) || length <= 0) {
-            throw new Error("The periodic length must be a positive integer.")
+            throw new InvalidArgumentError("The periodic length must be a positive integer.")
         }
 
         if (length > p) {
-            throw new Error(`The periodic length (${length}) cannot exceed the number of decimal digits (${p}).`)
+            throw new InvalidArgumentError(`The periodic length (${length}) cannot exceed the number of decimal digits (${p}).`)
         }
 
         const power = Math.pow(10, p)
@@ -661,7 +662,7 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
 
         // if p is not a safe integer, throw error
         if (!Number.isSafeInteger(p)) {
-            throw new Error("The root must be an integer.")
+            throw new InvalidArgumentError("The root must be an integer.")
         }
 
         // If negative, inverse the fraction
@@ -672,7 +673,7 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
 
         // if the fraction is negative and the root is even, throw error
         if (this.isNegative() && p % 2 === 0) {
-            throw new Error("The root of a negative number must be odd.")
+            throw new MathError("The root of a negative number must be odd.")
         }
 
         // get the sign of the fraction and make it positive

package/src/coefficients/root.ts

@@ -2,6 +2,7 @@ import {Fraction} from "./fraction"
 import type {IExpression, InputValue, IPiMathObject} from "../pimath.interface"
 import {stripParenthesis} from "../helpers"
 import {Numeric} from "../numeric"
+import {InvalidArgumentError, MathError, ParseError} from "../errors"
 
 export class Root implements IPiMathObject<Root>, IExpression<Root> {
     #factor: Fraction
@@ -109,7 +110,7 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
             this.index !== rt.index ||
             !this.radical.isEqual(rt.radical)
         ) {
-            throw new Error("Add can only be done with two same index and radical")
+            throw new MathError("Add can only be done with two same index and radical")
         }
 
         this.factor.add(rt.factor)
@@ -133,7 +134,7 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
         // set the index
         this.index = index
 
-        // set the racial
+        // set the radical
         this.radical = new Fraction(radical)
 
         // set the factor if any
@@ -158,7 +159,7 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
 
     set index(value: number) {
         if (!Number.isSafeInteger(value) || value <= 0) {
-            throw new Error("Index must be a strictly positive integer.")
+            throw new InvalidArgumentError("Index must be a strictly positive integer.")
         }
         this.#index = value
     }
@@ -212,7 +213,7 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
             return this
         }
 
-        throw new Error('Multiply can only be done if radical or index as equals.')
+        throw new MathError('Multiply can only be done if radical or index as equals.')
     }
 
     one(): this {
@@ -334,7 +335,7 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
     #parse_root(value: string): this {
         // Format: [factor]root([index])[radical] or [factor]root([index])([radical])
         const match = /^(.*?)root\((\d+)\)\(?([^)]+)/.exec(value)
-        if (!match) throw new Error(`Invalid root format: "${value}"`)
+        if (!match) throw new ParseError(`Invalid root format: "${value}"`)
 
         const [, factor, index, radical] = match
         this.index = +index

package/src/errors.ts

@@ -0,0 +1,45 @@
+/**
+ * Typed error hierarchy for PiMath.
+ *
+ * All PiMath errors extend {@link PiMathError}, so a consumer can catch every
+ * library error at once with `catch (e) { if (e instanceof PiMathError) ... }`,
+ * or discriminate a specific kind with `instanceof ParseError`, etc.
+ *
+ * The original error (e.g. piexpression's ParseError) is chained through the
+ * standard ES2022 `cause` option.
+ */
+export class PiMathError extends Error {
+    constructor(message: string, options?: { cause?: unknown }) {
+        super(message, options)
+        // Use the concrete subclass name (ParseError, MathError, ...).
+        this.name = new.target.name
+    }
+}
+
+/** The input string cannot be parsed into the target object. */
+export class ParseError extends PiMathError {
+}
+
+/** Incompatible dimensions (matrix, vector, point, ...). */
+export class DimensionError extends PiMathError {
+}
+
+/** Mathematically invalid operation on otherwise valid inputs. */
+export class MathError extends PiMathError {
+}
+
+/** An argument is invalid (outside of string parsing). */
+export class InvalidArgumentError extends PiMathError {
+}
+
+/** The called method is not implemented yet. */
+export class NotImplementedError extends PiMathError {
+}
+
+/** An index is out of range. */
+export class IndexError extends PiMathError {
+}
+
+/** An operation was attempted on an object in an invalid/uninitialized state. */
+export class StateError extends PiMathError {
+}

package/src/geometry/TupleN.ts

@@ -6,6 +6,7 @@
 
 import {Fraction} from "../coefficients"
 import type {InputValue} from "../pimath.interface"
+import {DimensionError} from "../errors"
 
 export abstract class TupleN {
     #array: Fraction[] = []
@@ -72,7 +73,7 @@ export abstract class TupleN {
 
     setDimension(value = 2): this {
         if (value < 2) {
-            throw new Error('Dimension must be at least 2')
+            throw new DimensionError('Dimension must be at least 2')
         }
 
         if (value < this.dimension) {
@@ -106,14 +107,14 @@ export abstract class TupleN {
 
     get z(): Fraction {
         if (this.dimension < 3) {
-            throw new Error('Vector is not 3D')
+            throw new DimensionError('Vector is not 3D')
         }
         return this.#array[2]
     }
 
     set z(value: Fraction | number | string) {
         if (this.dimension < 3) {
-            throw new Error('Vector is not 3D')
+            throw new DimensionError('Vector is not 3D')
         }
         this.#array[2] = new Fraction(value)
         this.#onChange?.()

package/src/geometry/geomMath.ts

@@ -1,6 +1,7 @@
 import {Fraction} from "../coefficients"
 import type {Vector} from "./vector"
 import type {Point} from "./point"
+import {DimensionError} from "../errors"
 
 type V = Vector | Point
 export function areVectorsEquals(v1: V, v2: V): boolean {
@@ -39,12 +40,12 @@ export function determinantFromVectors(...values: V[]): Fraction {
     // TODO: Make it work for vectors of dimension n
     // Check if the vectors are in the same dimension
     if (values.some((value) => value.dimension !== values[0].dimension)) {
-        throw new Error('All vectors must have the same dimension')
+        throw new DimensionError('All vectors must have the same dimension')
     }
 
     // Check if the vectors are in dimension 2 or 3 and that the number of values is correct
     if (values[0].dimension !== values.length ) {
-        throw new Error(`The determinant of dimension ${values[0].dimension} must have the same number of vectors (${values.length} given)`)
+        throw new DimensionError(`The determinant of dimension ${values[0].dimension} must have the same number of vectors (${values.length} given)`)
     }
 
     // Calculate the determinant 2x2

package/src/geometry/line.ts

@@ -10,6 +10,7 @@ import {type InputValue, type IPiMathObject, LinePropriety} from "../pimath.inte
 import {randomIntSym} from "../randomization/rndHelpers"
 import {Point} from "./point"
 import {Root} from "../coefficients/root"
+import {ParseError} from "../errors"
 
 enum LINE_DISPLAY {
     CARTESIAN,
@@ -83,12 +84,13 @@ export class Line implements IPiMathObject<Line> {
 
             if (typeof values[0] === "string") {
                 // It's a string - create an Equation from it.
+                // A malformed string throws (ParseError) instead of silently
+                // returning a half-built Line.
                 try {
                     const E = new Equation(values[0])
                     return this.parse(E)
                 } catch (e) {
-                    console.warn(e)
-                    return this
+                    throw new ParseError(`Cannot parse "${values[0]}" as a Line`, {cause: e})
                 }
             }
         }

package/src/geometry/line3.ts

@@ -6,6 +6,7 @@ import {Fraction} from "../coefficients/fraction"
 import {Polynom} from "../algebra/polynom"
 import {Monom} from "../algebra/monom"
 import {randomIntSym} from "../randomization/rndHelpers"
+import {NotImplementedError} from "../errors"
 import {Vector} from "./vector"
 import {Point} from "./point"
 import {Line3Propriety} from "../pimath.interface"
@@ -134,7 +135,7 @@ export class Line3 {
 
     intersection = (line: Line3): { point: Vector, hasIntersection: boolean, isParallel: boolean, isSame: boolean } => {
 
-        throw new Error('Method not implemented.')
+        throw new NotImplementedError('Method not implemented.')
     }
 
     // ------------------------------------------
@@ -144,19 +145,19 @@ export class Line3 {
 
     isParallelTo = (line: Line3): boolean => {
         // Do they have the isSame direction ?
-        throw new Error('Method not implemented.')
+        throw new NotImplementedError('Method not implemented.')
     }
 
     isPerpendicularTo = (line: Line3): boolean => {
-        throw new Error('Method not implemented.')
+        throw new NotImplementedError('Method not implemented.')
     }
 
     isSameAs = (line: Line3): boolean => {
-        throw new Error('Method not implemented.')
+        throw new NotImplementedError('Method not implemented.')
     }
 
     isVertical = (): boolean => {
-        throw new Error('Method not implemented.')
+        throw new NotImplementedError('Method not implemented.')
     }
 
     get point(): Point {
@@ -196,7 +197,7 @@ export class Line3 {
     // }
 
     simplify = (): this => {
-        throw new Error('Method not implemented.')
+        throw new NotImplementedError('Method not implemented.')
         // const lcm = Numeric.lcm(this.#a.denominator, this.#b.denominator, this.#c.denominator),
         //     gcd = Numeric.gcd(this.#a.numerator, this.#b.numerator, this.#c.numerator)
 

package/src/geometry/plane3.ts

@@ -5,6 +5,7 @@ import {Line3} from "./line3"
 import {Point} from "./point"
 import {Vector} from "./vector"
 import type {Plane3Config} from "../pimath.interface"
+import {DimensionError, NotImplementedError} from "../errors"
 
 
 export class Plane3 {
@@ -110,7 +111,7 @@ export class Plane3 {
         let direction: Vector
         if (value instanceof Vector) {
             if (value.dimension !== 3) {
-                throw new Error('Vector is not 3D')
+                throw new DimensionError('Vector is not 3D')
             }
 
             direction = value
@@ -153,7 +154,7 @@ export class Plane3 {
         // Solve the asSystem:
         // p1 // p2 // z=0
         const pt = new Point(0, 0, 0)
-        throw new Error('Intersection with plane  not yet implemented !')
+        throw new NotImplementedError('Intersection with plane  not yet implemented !')
         return new Line3(pt, direction)
     }
 

package/src/geometry/point.ts

@@ -6,6 +6,7 @@
 
 import {Fraction} from "../coefficients"
 import type {InputValue} from "../pimath.interface"
+import {DimensionError, InvalidArgumentError, ParseError} from "../errors"
 import {Root} from "../coefficients/root"
 import {TupleN} from "./TupleN"
 import type {Vector} from "./vector"
@@ -37,13 +38,13 @@ export class Point extends TupleN {
 
         if (values.length > 1) {
             if (values.some(x => x instanceof Point)) {
-                throw new Error('Creating a point with  multiple argument requires an input fraction')
+                throw new InvalidArgumentError('Creating a point with  multiple argument requires an input fraction')
             }
 
             const nbs: Fraction[] = values.map(x => new Fraction(x as InputValue<Fraction>))
 
             if (nbs.some(x => x.isNaN())) {
-                throw new Error('The given values are not a valid point string (a,b): ')
+                throw new ParseError('The given values are not a valid point string (a,b): ')
             }
 
             this.array = nbs
@@ -66,7 +67,7 @@ export class Point extends TupleN {
 
     distanceTo(B: Point): Root {
         if (this.dimension !== B.dimension) {
-            throw new Error('The two points must have the same dimensions.')
+            throw new DimensionError('The two points must have the same dimensions.')
         }
 
         const AB = this.array
@@ -91,7 +92,7 @@ export class Point extends TupleN {
 
     middleOf(V1: Point, V2: Point): this {
         if (V1.dimension !== V2.dimension) {
-            throw new Error('Vectors must be the same dimension')
+            throw new DimensionError('Vectors must be the same dimension')
         }
 
         this.array = []

package/src/geometry/sphere3.ts

@@ -2,6 +2,7 @@ import {Point} from "./point"
 import {Fraction} from "../coefficients"
 import {Equation, Polynom} from "../algebra"
 import type {InputValue} from "../pimath.interface"
+import {StateError} from "../errors"
 
 enum SPHERE3_FORMAT {
     DEVELOPPED,
@@ -66,21 +67,21 @@ export class Sphere3 {
 
     get center(): Point {
         if (this.#center === undefined) {
-            throw new Error('Sphere3 is undefined')
+            throw new StateError('Sphere3 is undefined')
         }
         return this.#center
     }
 
     get squareRadius(): Fraction {
         if (this.#squareRadius === undefined) {
-            throw new Error('Sphere3 is undefined')
+            throw new StateError('Sphere3 is undefined')
         }
         return this.#squareRadius
     }
 
     get radius(): { tex: string, display: string, value: number } {
         if (this.#squareRadius === undefined) {
-            throw new Error('Sphere3 is undefined')
+            throw new StateError('Sphere3 is undefined')
         }
 
         if (this.#squareRadius.isSquare()) {
@@ -100,7 +101,7 @@ export class Sphere3 {
 
     get equation(): Equation {
         if (this.#equation === undefined) {
-            throw new Error('Sphere3 is undefined')
+            throw new StateError('Sphere3 is undefined')
         }
         return this.#equation
     }
@@ -133,7 +134,7 @@ export class Sphere3 {
 
     #output = (asTex: boolean): string => {
         if (this.#equation === undefined) {
-            throw new Error('Sphere3 is undefined')
+            throw new StateError('Sphere3 is undefined')
         }
 
         if (this.#format === SPHERE3_FORMAT.DEVELOPPED) {

package/src/geometry/triangle.ts

@@ -4,6 +4,7 @@ import {Vector} from "./vector"
 import {Point} from "./point"
 import type {InputValue, remarquableLines} from "../pimath.interface"
 import {Numeric} from "../numeric"
+import {IndexError, InvalidArgumentError} from "../errors"
 
 type TRIANGLE_SIDES = 'AB' | 'AC' | 'BC'
 
@@ -62,7 +63,7 @@ export class Triangle {
             const v: Fraction[] = values.map((x: unknown) => new Fraction(x as string))
 
             if (v.some(x => x.isNaN())) {
-                throw new Error('One of the values is not a valid number')
+                throw new InvalidArgumentError('One of the values is not a valid number')
             }
 
             return this.fromCoordinates(v[0], v[1], v[2], v[3], v[4], v[5])
@@ -436,7 +437,7 @@ export class Triangle {
         }
 
         if (d1 === undefined || d2 === undefined) {
-            throw new Error(`The point ${pt} does not exist`)
+            throw new IndexError(`The point ${pt} does not exist`)
         }
 
         const director = internal

package/src/geometry/vector.ts

@@ -6,6 +6,7 @@ import type {InputValue, IPiMathObject} from "../pimath.interface"
 import {Fraction} from "../coefficients"
 import {Numeric} from "../numeric"
 import {areVectorsColinears, areVectorsEquals, dotProduct} from "./geomMath"
+import {DimensionError, InvalidArgumentError} from "../errors"
 import {TupleN} from "./TupleN"
 import {type Point} from "./point"
 
@@ -25,7 +26,7 @@ export class Vector extends TupleN implements IPiMathObject<Vector> {
 
     public parse(...values: (Vector | Point)[] | InputValue<Fraction>[]): this {
         if (values.length === 0) {
-            throw new Error(`Invalid value`)
+            throw new InvalidArgumentError(`Invalid value`)
         }
 
         if (values.length === 1) {
@@ -38,7 +39,7 @@ export class Vector extends TupleN implements IPiMathObject<Vector> {
                 return this.fromString(values[0])
             }
 
-            throw new Error(`Invalid value`)
+            throw new InvalidArgumentError(`Invalid value`)
         }
 
         // Two values are given
@@ -48,7 +49,7 @@ export class Vector extends TupleN implements IPiMathObject<Vector> {
             // The two values are vectors
             if (A instanceof TupleN && B instanceof TupleN) {
                 if (A.dimension !== B.dimension) {
-                    throw new Error('Vectors must have the same dimension')
+                    throw new DimensionError('Vectors must have the same dimension')
                 }
 
                 this.array = B.array.map((x, index) => x.clone().subtract(A.array[index]))
@@ -100,7 +101,7 @@ export class Vector extends TupleN implements IPiMathObject<Vector> {
 
     cross(value: Vector): Vector {
         if (this.dimension !== 3 || value.dimension !== 3) {
-            throw new Error('Cross product can only be determined in 3D')
+            throw new DimensionError('Cross product can only be determined in 3D')
         }
 
         return new Vector(
@@ -171,7 +172,7 @@ export class Vector extends TupleN implements IPiMathObject<Vector> {
 
     normal = (): this => {
         if (this.dimension >= 3) {
-            throw new Error('Normal vector can only be determined in 2D')
+            throw new DimensionError('Normal vector can only be determined in 2D')
         }
 
         const x = this.x.clone().opposite()