pimath 0.1.40 → 0.2.1

package/src/geometry/vector.ts

@@ -2,143 +2,43 @@
  * Vector2D module contains everything necessary to handle 2d vectors.
  * @module Vector
  */
-import type { InputValue, IPiMathObject } from "../pimath.interface"
-import { Fraction } from "../coefficients/fraction"
-import { Numeric } from "../numeric"
-import { areVectorsColinears, areVectorsEquals, dotProduct } from "./geomMath"
+import type {InputValue, IPiMathObject} from "../pimath.interface"
+import {Fraction} from "../coefficients"
+import {Numeric} from "../numeric"
+import {areVectorsColinears, areVectorsEquals, dotProduct} from "./geomMath"
+import {TupleN} from "./TupleN"
+import {type Point} from "./point"
 
-export class Vector implements
-    IPiMathObject<Vector> {
-    #array: Fraction[] = []
-    #asPoint = false
+export class Vector extends TupleN implements IPiMathObject<Vector> {
+    constructor(...values: (Vector | Point)[] | InputValue<Fraction>[]) {
+        super()
 
-    constructor(...values: Vector[] | InputValue<Fraction>[]) {
         if (values.length > 0) {
             this.parse(...values)
         }
-    };
-
-    // ------------------------------------------
-    // Getter and setter
-    // ------------------------------------------
-    get array(): Fraction[] {
-        return this.#array
-    }
-
-    set array(value: Fraction[]) {
-        this.#array = value
-    }
-
-    get x(): Fraction {
-        return this.#array[0]
-    }
-
-    set x(value: Fraction | number | string) {
-        this.#array[0] = new Fraction(value)
-    }
-
-    get y(): Fraction {
-        return this.#array[1]
-    }
-
-    set y(value: Fraction | number | string) {
-        this.#array[1] = new Fraction(value)
-    }
-
-    get z(): Fraction {
-        if (this.dimension < 3) { throw new Error('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') }
-        this.#array[2] = new Fraction(value)
-    }
-
-    get asPoint(): boolean {
-        return this.#asPoint
-    }
-
-    set asPoint(value: boolean) {
-        this.#asPoint = value
-    }
-
-
-    get normSquare(): Fraction {
-        // Get the norm square of the vector
-        return this.array.reduce((acc, x) => acc.add(x.clone().pow(2)), new Fraction(0))
-    }
-
-    get norm(): number {
-        return Math.sqrt(this.normSquare.value)
-    }
-
-    get tex(): string {
-        if (this.#asPoint) {
-            return `\\left(${this.array.map(x => x.tex).join(';')}\\right)`
-        }
-
-        return `\\begin{pmatrix} ${this.array.map(x => x.tex).join(' \\\\ ')} \\end{pmatrix}`
-    }
-
-    get display(): string {
-        if (this.#asPoint) {
-            return `(${this.array.map(x => x.display).join(';')})`
-        }
-
-        return `((${this.array.map(x => x.display).join(',')}))`
-    }
-
-    setDimension(value = 2): this{
-        if (value < 2) {
-            throw new Error('Dimension must be at least 2')
-        }
-
-        if (value < this.dimension) {
-            this.#array = this.#array.slice(0, value)
-        } else if(value > this.dimension) {
-            for(let i = this.dimension; i < value; i++) {
-                this.#array.push(new Fraction(0))
-            }
-        }
 
         return this
-    }
-    get dimension(): number {
-        return this.array.length
-    }
+    };
 
     // ------------------------------------------
-    // Creation / parsing functions
-    // ------------------------------------------
-    get isNull(): boolean {
-        return this.array.every(x => x.isZero())
-    }
-
-    static asTex(...values: string[]): string {
-        return `\\begin{pmatrix} ${values.join(' \\\\ ')} \\end{pmatrix}`
-    }
-    static asDisplay(...values: string[]): string {
-        return `((${values.join(',')}))`
-    }
+    // Getter and setter
 
-    public defineAsPoint(value?: boolean): this {
-        this.#asPoint = value !== false
-        return this
-    }
-    public parse(...values: Vector[] | InputValue<Fraction>[]): this {
+    public parse(...values: (Vector | Point)[] | InputValue<Fraction>[]): this {
         if (values.length === 0) {
             throw new Error(`Invalid value`)
         }
 
         if (values.length === 1) {
-            if (values[0] instanceof Vector) {
-                return values[0].clone() as this
-            } else if (typeof values[0] === 'string') {
+            if (values[0] instanceof TupleN) {
+                this.array = values[0].copy()
+                return this
+            }
+
+            if (typeof values[0] === 'string') {
                 return this.fromString(values[0])
-            } else {
-                throw new Error(`Invalid value`)
             }
+
+            throw new Error(`Invalid value`)
         }
 
         // Two values are given
@@ -146,84 +46,56 @@ export class Vector implements
             const [A, B] = values
 
             // The two values are vectors
-            if (A instanceof Vector && B instanceof Vector) {
-                if (A.dimension !== B.dimension) { throw new Error('Vectors must have the same dimension') }
+            if (A instanceof TupleN && B instanceof TupleN) {
+                if (A.dimension !== B.dimension) {
+                    throw new Error('Vectors must have the same dimension')
+                }
 
-                this.#array = B.array.map((x, index) => x.clone().subtract(A.array[index]))
+                this.array = B.array.map((x, index) => x.clone().subtract(A.array[index]))
                 return this
             }
         }
 
         // Two ore more values as number, string, fraction...
-        this.#array = values.map(x => new Fraction(x as InputValue<Fraction>))
-
+        this.array = values.map(x => new Fraction(x as InputValue<Fraction>))
         return this
     }
 
     public clone(): Vector {
-        const V = new Vector()
-        V.array = this.copy()
-        V.asPoint = this.asPoint
-        return V
+        return new Vector(...this.copy())
     }
 
-    public copy(): Fraction[] {
-        return this.#array.map(x => x.clone())
+    get tex(): string {
+        return `\\begin{pmatrix} ${this.array.map(x => x.tex).join(' \\\\ ')} \\end{pmatrix}`
     }
 
-    zero = (): this => {
-        this.#array.forEach(x => x.zero())
-        return this
+    get display(): string {
+        return `((${this.array.map(x => x.display).join(',')}))`
     }
 
-    one = (): this => {
-        this.zero()
-        this.x.one()
-        return this
+    static asDisplay(...values: string[]): string {
+        return `((${values.join(',')}))`
     }
 
-    opposite = (): this => {
-        this.#array.forEach(x => x.opposite())
-        return this
+    static asTex(...values: string[]): string {
+        return `\\begin{pmatrix} ${values.join(' \\\\ ')} \\end{pmatrix}`
     }
 
     add = (V: Vector): this => {
-        this.#array.forEach((x, index) => x.add(V.array[index]))
+        this.array.forEach((x, index) => x.add(V.array[index]))
         return this
     }
 
-    subtract = (V: Vector): this => {
-        return this.add(V.clone().opposite())
-    }
+    angle = (V: Vector, sharp?: boolean, radian?: boolean): number => {
 
-    unit = (): this => {
-        const norm = this.norm
-        if (norm === 0) {
-            return this
+        let scalar = this.dot(V).value
+        if (sharp) {
+            scalar = Math.abs(scalar)
         }
 
-        return this.divideByScalar(norm)
-    }
-
-    middleOf(V1: Vector, V2: Vector): this {
-        if (V1.dimension !== V2.dimension) { throw new Error('Vectors must be the same dimension') }
-
-        this.array = []
-        V1.array.forEach((x, index) => {
-            this.array.push(x.clone().add(V2.array[index]).divide(2))
-        })
-
-        return this
-    }
-
-    translate(...values: Fraction[]): this {
-        this.array.forEach((x, index) => x.add(values[index]))
-        return this
-    }
-
+        const toDegree = radian ? 1 : 180 / Math.PI
 
-    dot = (V: Vector): Fraction => {
-        return dotProduct(this, V)
+        return toDegree * Math.acos(scalar / (this.norm * V.norm))
     }
 
     cross(value: Vector): Vector {
@@ -238,104 +110,116 @@ export class Vector implements
         )
     }
 
-    normal = (): this => {
-        if (this.dimension >= 3) { throw new Error('Normal vector can only be determined in 2D') }
+    // ------------------------------------------
+    // Creation / parsing functions
 
-        const x = this.x.clone().opposite(),
-            y = this.y.clone()
-        this.#array[0] = y
-        this.#array[1] = x
-        return this
+    divideByScalar = (k: InputValue<Fraction>): this => {
+        return this.multiplyByScalar(new Fraction(k).inverse())
     }
 
-    isZero(): boolean {
-        return this.array.every(x => x.isZero())
-    }
-    isOne(): boolean {
-        return this.array.every((x, index) => index === 0 ? x.isOne() : x.isZero())
+    dot = (V: Vector |Point): Fraction => {
+        return dotProduct(this, V)
     }
 
-    isEqual = (v: Vector): boolean => {
-        return areVectorsEquals(this, v)
+    override fromString(value: string): this {
+        if (value.startsWith('((') && value.endsWith('))')) {
+            return super.fromString(value.slice(1, -1))
+        }
+
+        return super.fromString(value)
     }
 
     isColinearTo = (v: Vector): boolean => {
         return areVectorsColinears(this, v)
     }
 
+    isEqual = (v: Vector): boolean => {
+        return areVectorsEquals(this, v)
+    }
+
     isNormalTo = (v: Vector): boolean => {
         return this.dot(v).isZero()
     }
 
+    // ------------------------------------------
+    get isNull(): boolean {
+        return this.array.every(x => x.isZero())
+    }
+
+    isOne(): boolean {
+        return this.array.every((x, index) => index === 0 ? x.isOne() : x.isZero())
+    }
+
+    isZero(): boolean {
+        return this.array.every(x => x.isZero())
+    }
+
     multiplyByScalar = (k: InputValue<Fraction>): this => {
         const scalar = new Fraction(k)
         this.array.forEach(x => x.multiply(scalar))
         return this
     }
 
-    divideByScalar = (k: InputValue<Fraction>): this => {
-        return this.multiplyByScalar(new Fraction(k).inverse())
+    get norm(): number {
+        return Math.sqrt(this.normSquare.value)
     }
 
-    simplify = (): this => {
-        // Multiply by the lcm of denominators.
-        return this
-            .multiplyByScalar(
-                Numeric.lcm(...this.array.map(x => x.denominator))
-            )
-            .divideByScalar(
-                Numeric.gcd(...this.array.map(x => x.numerator))
-            ).
-            multiplyByScalar(
-                this.x.isNegative() ? -1 : 1
-            )
+    get normSquare(): Fraction {
+        // Get the norm square of the vector
+        return this.array.reduce((acc, x) => acc.add(x.clone().pow(2)), new Fraction(0))
     }
 
-    angle = (V: Vector, sharp?: boolean, radian?: boolean): number => {
-
-        let scalar = this.dot(V).value
-        if (sharp) {
-            scalar = Math.abs(scalar)
+    normal = (): this => {
+        if (this.dimension >= 3) {
+            throw new Error('Normal vector can only be determined in 2D')
         }
 
-        const toDegree = radian ? 1 : 180 / Math.PI
+        const x = this.x.clone().opposite()
+        const y = this.y.clone()
 
-        return toDegree * Math.acos(scalar / (this.norm * V.norm))
+        this.array[0] = y
+        this.array[1] = x
+        return this
     }
 
+    one = (): this => {
+        this.zero()
+        this.x.one()
+        return this
+    }
 
-    fromString = (value: string): this => {
-        // Remove the first letter if it's a parenthesis.
-        if (value.startsWith('(')) {
-            value = value.substring(1)
-        }
+    opposite = (): this => {
+        this.array.forEach(x => x.opposite())
+        return this
+    }
 
-        // Remove the last letter if it's a parenthesis.
-        if (value.endsWith(')')) {
-            value = value.substring(0, value.length - 1)
-        }
+    simplify = (): this => {
+        const lcm = Numeric.lcm(...this.array.map(x => x.denominator))
+        const gcd = Numeric.gcd(...this.array.map(x => x.numerator))
 
-        // Split comma, semi colon or single space.
-        const components = value.split(/[,;\s]/g)
-            .filter((v) => v.trim() !== '')
+        this.multiplyByScalar(new Fraction(lcm, gcd))
 
-        // there must be at least two components.
-        if (components.length < 2) {
-            return this
-        }
+        if(this.x.isNegative()) this.opposite()
 
-        // Validate the fraction values.
-        this.#array = components.map(x => new Fraction(x))
         return this
     }
 
-    distanceTo(item: Vector): { value: number, fraction: Fraction, tex: string } {
-        const V = new Vector(this, item)
+    subtract = (V: Vector): this => {
+        return this.add(V.clone().opposite())
+    }
+
+    translate(...values: Fraction[]): this {
+        this.array.forEach((x, index) => x.add(values[index]))
+        return this
+    }
 
-        return {
-            value: V.norm,
-            fraction: V.normSquare,
-            tex: V.tex
+    unit = (): this => {
+        const norm = this.norm
+        if (norm === 0) {
+            return this
         }
+
+        return this.divideByScalar(norm)
     }
+
 }

package/src/index.ts

@@ -1,29 +1,30 @@
 // Expose as global
-export * from "./coefficients"
-export * from "./algebra"
-export * from "./geometry"
-
-// Import items individually to make a global object
-
 // Coefficients
-import {Fraction, NthRoot} from "./coefficients"
+import {Fraction, Root} from "./coefficients"
 
 // Algebra
-import {Equation, Factor, LinearSystem, LogicalSet, Monom, PolyFactor, Polynom, Matrix} from "./algebra"
+import {Equation, Factor, LinearSystem, LogicalSet, Matrix, Monom, PolyFactor, Polynom} from "./algebra"
 
 // Geometry
-import {Circle, Line, Line3, Plane3, Point, Triangle, Vector, Sphere3} from "./geometry"
+import {Circle, Line, Line3, Plane3, Point, Sphere3, Triangle, Vector} from "./geometry"
 
 // Numeric
 import {Numeric} from "./numeric"
-export {Numeric}
 
 // NumExp
 import {NumExp} from "piexpression"
-export {NumExp}
 
 // randomization
 import {Random} from "./randomization/random"
+
+// export everything to make them available as module
+export * from "./coefficients"
+export * from "./algebra"
+export * from "./geometry"
+export * from "./analyze"
+
+export {Numeric}
+export {NumExp}
 export {Random}
 
 // Typesetting
@@ -33,7 +34,7 @@ export type * from "./pimath.interface"
 const PiMath = {
     Numeric,
     Fraction,
-    Root: NthRoot,
+    Root,
     Monom,
     Polynom,
     Equation,

package/src/numeric.ts

@@ -165,19 +165,16 @@ function round(value: number, decimals = 2): number {
 function greatestPower(value: number, index: number): number {
     let search_value = Math.floor(Math.pow(value, 1 / index))
 
-    let radical = value
-    let factor = 1
+    const radical = value
+    const factor = 1
 
     while (search_value > 1) {
         const pow = Math.pow(search_value, index)
-        if (radical % pow) {
-            factor *= search_value
-            radical = radical / pow
-
-            search_value = Math.floor(Math.pow(radical, 1 / index))
-        }else{
-            search_value--
+        if (radical % pow === 0) {
+            return pow
         }
+
+        search_value--
     }
 
     return factor

package/src/pimath.interface.ts

@@ -1,8 +1,9 @@
-import type {Fraction, NthRoot} from "./coefficients"
+import type {Fraction} from "./coefficients"
 import type {Equation, Factor, Monom} from "./algebra"
 import type {Line, Point, Vector} from "./geometry"
+import type {Solution} from "./analyze/solution"
 
-export type InputValue<T> = T | string | number | Fraction | NthRoot;
+export type InputValue<T> = T | string | number | Fraction // | Root;
 export type InputAlgebra<T> = InputValue<T> | Monom
 export type literalType<T> = Record<string, T>;
 
@@ -26,7 +27,8 @@ export interface IPiMathObject<T> {
 
     clone(): T;
 }
-export interface IExpressionBase<T>{
+
+export interface IExpressionBase<T> {
     add(value: InputValue<T>): T;
 
     isEqual(value: InputValue<T>): boolean;
@@ -46,12 +48,13 @@ export interface IExpressionBase<T>{
     zero(): T;
 }
 
-export interface IExpressionMultiply<T> extends IExpressionBase<T>{
+export interface IExpressionMultiply<T> extends IExpressionBase<T> {
     multiply(value: InputValue<T>): T;
 
     pow(value: number): T;
 }
-export interface IExpression<T> extends IExpressionMultiply<T>{
+
+export interface IExpression<T> extends IExpressionMultiply<T> {
     divide(value: InputValue<T>): T | null;
 
     inverse(): T | undefined;
@@ -65,7 +68,7 @@ export interface IEquation<T> {
 
     reduce(): T;
 
-    solve(): ISolution[]
+    solve(): Solution[]
 }
 
 export interface IAlgebra<T> {
@@ -86,18 +89,17 @@ export interface IAnalyse<T> {
     primitive(): T;
 }
 
-export interface ISolution {
-    display: string,
-    exact: Fraction | boolean
-    tex: string,
-    value: number,
-    variable: string,
+export type TABLE_OF_SIGNS_VALUES = '-' | '+' | 'h' | 'z' | 't' | 'd' | 'u' | 'n' | ''
+
+export interface TABLE_OF_SIGNS {
+    roots: Solution[],
+    signs: TABLE_OF_SIGNS_VALUES[]
 }
 
-export type TABLE_OF_SIGNS_VALUES = '-'|'+'|'h'|'z'|'t'|'d'|'u'|'n'|''
+export interface FACTOR_TABLE_OF_SIGNS extends TABLE_OF_SIGNS {
+    factor: Factor
+}
 
-export interface TABLE_OF_SIGNS {roots: ISolution[], signs: TABLE_OF_SIGNS_VALUES[]}
-export interface FACTOR_TABLE_OF_SIGNS extends TABLE_OF_SIGNS {factor: Factor}
 export interface POLYFACTOR_TABLE_OF_SIGNS extends TABLE_OF_SIGNS {
     factors: FACTOR_TABLE_OF_SIGNS[]
 }
@@ -131,30 +133,30 @@ export interface remarquableLines {
         'A': Line,
         'B': Line,
         'C': Line,
-        'intersection': Vector | null
-    },
+        'intersection': Point | null
+    } | null,
     externalBisectors: {
         'A': Line,
         'B': Line,
         'C': Line,
-        'intersection': Vector | null
-    }
+        'intersection': Point | null
+    } | null,
     'heights': {
         'A': Line,
         'B': Line,
         'C': Line,
-        'intersection': Vector | null
-    },
+        'intersection': Point | null
+    } | null,
     'medians': {
         'A': Line,
         'B': Line,
         'C': Line,
-        'intersection': Vector | null
-    },
+        'intersection': Point | null
+    } | null,
     'mediators': {
-        'AB': Line,
-        'AC': Line,
-        'BC': Line,
-        'intersection': Vector | null
-    },
+        'a': Line,
+        'b': Line,
+        'c': Line,
+        'intersection': Point | null
+    } | null
 }