pimath 0.0.125 → 0.0.127

package/src/maths/algebra/polynom.ts

@@ -7,8 +7,6 @@ import {Shutingyard, ShutingyardType, Token} from '../shutingyard';
 import {Numeric} from '../numeric';
 import {Fraction} from "../coefficients/fraction";
 import {Equation, ISolution} from "./equation";
-import {Random} from "../randomization/random";
-import {loadHighlighter} from "typedoc/dist/lib/utils/highlighter";
 
 export type PolynomParsingType = string | Polynom | number | Fraction | Monom
 
@@ -24,12 +22,12 @@ export interface IEuclidian {
  * ```
  */
 export class Polynom {
+    private _rawString: string;
     private _dirty_factors: boolean
     private _dirty_zeroes: boolean
     private _euclidianCache: { [Key: string]: IEuclidian }
     private _factors: Polynom[];
     private _monoms: Monom[];
-    private _rawString: string;
     private _texString: string;
     private _zeroes: ISolution[]
 
@@ -49,12 +47,13 @@ export class Polynom {
         return this;
     }
 
-    get euclidianCache(): { [p: string]: IEuclidian } {
-        return this._euclidianCache;
+    // ------------------------------------------
+    get dirty_factors(): boolean {
+        return this._dirty_factors;
     }
 
-    set euclidianCache(value: { [p: string]: IEuclidian }) {
-        this._euclidianCache = value;
+    set dirty_factors(value: boolean) {
+        this._dirty_factors = value;
     }
 
     get dirty_zeroes(): boolean {
@@ -65,26 +64,12 @@ export class Polynom {
         this._dirty_zeroes = value;
     }
 
-    // ------------------------------------------
-    get dirty_factors(): boolean {
-        return this._dirty_factors;
-    }
-
-    set dirty_factors(value: boolean) {
-        this._dirty_factors = value;
-    }
-
-    // ------------------------------------------
-    get monoms() {
-        return this._monoms;
-    }
-
-    set monoms(M: Monom[]) {
-        this._monoms = M;
+    get euclidianCache(): { [p: string]: IEuclidian } {
+        return this._euclidianCache;
     }
 
-    get zeroes(): ISolution[] {
-        return this.getZeroes()
+    set euclidianCache(value: { [p: string]: IEuclidian }) {
+        this._euclidianCache = value;
     }
 
     get factors(): Polynom[] {
@@ -96,10 +81,23 @@ export class Polynom {
         this._factors = value;
     }
 
+    // ------------------------------------------
+    get monoms() {
+        return this._monoms;
+    }
+
+    set monoms(M: Monom[]) {
+        this._monoms = M;
+    }
+
     get texString(): string {
         return this._texString;
     }
 
+    get zeroes(): ISolution[] {
+        return this.getZeroes()
+    }
+
     get texFactors(): string {
         this.factorize()
 
@@ -439,7 +437,7 @@ export class Polynom {
         this.mark_as_dirty()
 
         if (value instanceof Polynom) {
-            return this.multiplyByPolynom(value);
+            return this.multiplyByPolynom(value)
         } else if (value instanceof Fraction) {
             return this.multiplyByFraction(value);
         } else if (value instanceof Monom) {
@@ -471,33 +469,33 @@ export class Polynom {
         if (P.variables.length === 0) {
             let q = this.clone().divide(P)
             return {
-                quotient: this.clone().divide(P),
+                quotient: this.clone().divide(P).reduce(),
                 reminder: new Polynom().zero()
             }
         }
 
         // Get at least a letter
-
         const maxMP: Monom = P.monomByDegree(undefined, letter);
         const degreeP: Fraction = P.degree(letter);
 
         let newM: Monom;
 
         // Make the euclidian division of the two polynoms.
-        let MaxIteration = this.degree(letter).clone().multiply(2);
-        while (reminder.degree(letter).geq(degreeP) && MaxIteration.isPositive()) {
-            MaxIteration.subtract(1)
+        let MaxIteration = this.degree(letter).value * 2;
+        while (reminder.degree(letter).geq(degreeP) && MaxIteration > 0) {
+            MaxIteration--
 
             // Get the greatest monom divided by the max monom of the divider
             newM = reminder.monomByDegree(undefined, letter).clone().divide(maxMP);
 
-            if (newM.isZero()) {
-                break;
-            }
+            if (newM.isZero()) continue;
 
             // Get the new quotient and reminder.
             quotient.add(newM);
-            reminder.subtract(P.clone().multiply(newM));
+            reminder.subtract(P.clone().multiply(newM)).reduce();
+
+            // Check if the reminder is zero.
+            if (newM.degree(letter).isZero()) break
         }
 
         quotient.reduce()
@@ -517,11 +515,11 @@ export class Polynom {
         } else if (value instanceof Polynom) {
             if (value.monoms.length === 1 && value.variables.length === 0) {
                 return this.divideByFraction(value.monoms[0].coefficient)
-            }else {
+            } else {
                 let {quotient, reminder} = this.euclidian(value)
-                if(reminder.isZero()){
+                if (reminder.isZero()) {
                     return quotient
-                }else{
+                } else {
                     console.log(`${this.tex} is not divideable by ${value.tex}`)
                     return new Polynom().zero()
                 }
@@ -663,19 +661,21 @@ export class Polynom {
         let polyFactors = factors.map(x => new Polynom(x));
 
         // polyFactors contain all polynoms.
-        let checkPolyFactors = polyFactors.filter(x=>x.degree().geq(1) && !x.commonMonom().isOne())
+        let checkPolyFactors = polyFactors.filter(x => x.degree().geq(1) && !x.commonMonom().isOne())
 
         // Some polynoms are not completely factorized.
-        if(checkPolyFactors.length>0 && !soft){return false}
-        if(checkPolyFactors.length>0 && soft){
-            polyFactors = polyFactors.filter(x=>x.commonMonom().isOne())
+        if (checkPolyFactors.length > 0 && !soft) {
+            return false
+        }
+        if (checkPolyFactors.length > 0 && soft) {
+            polyFactors = polyFactors.filter(x => x.commonMonom().isOne())
 
             let FactorizedConstant = new Fraction().one()
-            for(let p of checkPolyFactors){
+            for (let p of checkPolyFactors) {
                 let k = p.commonMonom(),
                     pFactor = p.clone().divide(k)
 
-                if(k.degree().isZero()){
+                if (k.degree().isZero()) {
                     FactorizedConstant.multiply(k.coefficient)
                     polyFactors.push(pFactor.clone())
                 }
@@ -786,39 +786,57 @@ export class Polynom {
     // -------------------------------------
     reduce = (): Polynom => {
         // Reduce the polynom
-        let values = [...this._monoms],
+        let values = this._monoms.map(x => x.clone()),
             vars = [...this.variables]
 
-        this._monoms = []
-
-        let coeffs = values.filter(x => x.variables.length === 0)
-
-        if (coeffs.length > 0) {
-            this._monoms.push(coeffs.reduce((a, b) => a.add(b)))
-        }
-
-        // Build the new monoms
-        for (let letter of vars) {
-            // Monom with same letters, but might be of different degrees
-            let M = values.filter(x => x.hasLetter(letter))
-
-            while (M.length > 0) {
-                // Take the first element
-                const m = M.shift(), degree = m.degree(letter)
-
-                for (let a of M.filter(x => x.degree(letter).isEqual(degree))) {
-                    m.add(a)
+        // Group the monoms by similarity
+        let i = 0
+        while (i < this._monoms.length) {
+            for (let j = i + 1; j < this._monoms.length; j++) {
+                if (this._monoms[i].isSameAs(this._monoms[j])) {
+                    this._monoms[i].add(this._monoms[j])
+                    this._monoms.splice(j, 1)
+                    if (this._monoms[i].isZero()) {
+                        this._monoms[i] = new Monom().zero()
+                    }
+                    j--
                 }
-
-                this._monoms.push(m)
-
-                // Make the new array.
-                M = M.filter(x => x.degree(letter).isNotEqual(degree))
             }
-            // reduce the monom
-
+            i++
         }
 
+        //
+        //
+        //
+        // let coeffs = values.filter(x => x.variables.length === 0)
+        //
+        // if (coeffs.length > 0) {
+        //     this._monoms.push(coeffs.reduce((a, b) => a.add(b)))
+        // }
+        //
+        // // Build the new monoms
+        // for (let letter of vars) {
+        //     // Monom with same letters, but might be of different degrees
+        //     let M = values.filter(x => x.hasLetter(letter))
+        //
+        //     while (M.length > 0) {
+        //         // Take the first element
+        //         const m = M.shift(), degree = m.degree(letter)
+        //
+        //         for (let a of M.filter(x => x.degree(letter).isEqual(degree))) {
+        //             m.add(a)
+        //         }
+        //
+        //         this._monoms.push(m)
+        //
+        //         // Make the new array.
+        //         M = M.filter(x => x.degree(letter).isNotEqual(degree))
+        //     }
+        //     // reduce the monom
+        //
+        // }
+
+
         // Remove all null monoms
         this._monoms = this._monoms.filter((m) => {
             return m.coefficient.value !== 0
@@ -832,11 +850,14 @@ export class Polynom {
         if (this.length === 0) {
             return new Polynom().zero();
         }
+
         return this.reorder();
     };
 
     reorder = (letter: string = 'x', revert?: boolean): Polynom => {
-        if(revert===undefined){revert = false}
+        if (revert === undefined) {
+            revert = false
+        }
 
         // TODO: Must handle multiple setLetter reorder system
         let otherLetters = this.variables.filter(x => x !== letter)
@@ -845,7 +866,7 @@ export class Polynom {
                 db = b.degree(letter).value
 
             // Values are different
-            if (da !== db) return revert?da-db : db - da
+            if (da !== db) return revert ? da - db : db - da
 
             // if values are equals, check other letters - it must be revert in that case !
             if (otherLetters.length > 0) {
@@ -854,7 +875,7 @@ export class Polynom {
                         db = b.degree(L).value
 
                     // Values are different
-                    if (da !== db) return revert?da - db : db - da
+                    if (da !== db) return revert ? da - db : db - da
                 }
             }
 
@@ -1045,16 +1066,10 @@ export class Polynom {
                                 dC = x.monoms[x.monoms.length - 1]
 
                             // Check last item (degree zero)
-                            if (!pC.isDivisible(dC)) {
-                                return false
-                            }
+                            if (!pC.isDivisible(dC)) return false
 
                             // Check the first item (degree max)
-                            if (!pX.isDivisible(dX)) {
-                                return false
-                            }
-
-                            return true
+                            return pX.isDivisible(dX);
                         })
                     }
                 }

package/src/maths/geometry/line.ts

@@ -9,7 +9,6 @@ import {Fraction} from "../coefficients/fraction";
 import {Equation} from "../algebra/equation";
 import {Polynom} from "../algebra/polynom";
 import {Random} from "../randomization/random";
-import {LinearSystem} from "../algebra/linearSystem";
 import {Monom} from "../algebra/monom";
 
 export enum LinePropriety {
@@ -26,7 +25,20 @@ export class Line {
     private _referencePropriety: LinePropriety
     private _referenceLine: Line
     private _reduceBeforeDisplay: boolean
+    // ax + by + c = 0
+    private _a: Fraction;
+    private _b: Fraction;
+    private _c: Fraction;
+    private _OA: Point;
+    private _d: Vector;
+    private _n: Vector;
+    private _exists: boolean
 
+    /**
+     * Value can be a mix of:
+     *
+     * @param values
+     */
     constructor(...values: unknown[]) {
 
         this._exists = false;
@@ -39,19 +51,17 @@ export class Line {
         return this;
     }
 
-    // ax + by + c = 0
-    private _a: Fraction;
-
     get a(): Fraction {
         return this._a;
     }
 
+    // ------------------------------------------
+    // Getter and setter
+
     set a(value: Fraction) {
         this._a = value;
     }
 
-    private _b: Fraction;
-
     get b(): Fraction {
         return this._b;
     }
@@ -60,21 +70,14 @@ export class Line {
         this._b = value;
     }
 
-    private _c: Fraction;
-
     get c(): Fraction {
         return this._c;
     }
 
-    // ------------------------------------------
-    // Getter and setter
-
     set c(value: Fraction) {
         this._c = value;
     }
 
-    private _OA: Point;
-
     get OA(): Point {
         return this._OA;
     }
@@ -83,8 +86,6 @@ export class Line {
         this._OA = value;
     }
 
-    private _d: Vector;
-
     get d(): Vector {
         return this._d;
     }
@@ -93,14 +94,10 @@ export class Line {
         this._d = value;
     }
 
-    private _n: Vector;
-
     get n(): Vector {
         return this._n;
     }
 
-    private _exists: boolean
-
     get exists(): boolean {
         return this._exists;
     }
@@ -108,19 +105,19 @@ export class Line {
     // ------------------------------------------
     get equation(): Equation {
         let equ = new Equation(new Polynom().parse('xy', this._a, this._b, this._c), new Polynom('0'))
-        if(this._reduceBeforeDisplay) {
+        if (this._reduceBeforeDisplay) {
             return equ.simplify();
-        }else{
+        } else {
             return equ
         }
     }
 
     get system(): { x: Equation, y: Equation } {
         let e1 = new Equation(
-            new Polynom('x'),
-            new Polynom(this._OA.x)
-                .add(new Monom('k').multiplyByNumber(this._d.x))
-        ),
+                new Polynom('x'),
+                new Polynom(this._OA.x)
+                    .add(new Monom('k').multiplyByNumber(this._d.x))
+            ),
             e2 = new Equation(
                 new Polynom('y'),
                 new Polynom(this._OA.y)

package/src/maths/geometry/point.ts

@@ -73,6 +73,20 @@ export class Point {
 
     // ------------------------------------------
     // Creation / parsing functions
+
+    get key(): string {
+        return `${this.x.display};${this.y.display}`
+    }
+
+    // ------------------------------------------
+    static pmatrix = (a: any, b: any, c?: any): string => {
+        if (c === undefined) {
+            return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\end{pmatrix}`;
+        } else {
+            return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\\\ ${c.tex ? c.tex : c} \\end{pmatrix}`;
+        }
+    };
+
     // ------------------------------------------
     parse = (...values: unknown[]): Point => {
         // Initialize the value.
@@ -103,9 +117,9 @@ export class Point {
             }
 
             // Value given as an object with {x: value, y: value}
-            if(values[0] instanceof PointXY){
-                    this._x = new Fraction(values[0].x).reduce()
-                    this._y = new Fraction(values[0].y).reduce()
+            if (values[0] instanceof PointXY) {
+                this._x = new Fraction(values[0].x).reduce()
+                this._y = new Fraction(values[0].y).reduce()
                 return this
             } else {
                 return this.zero()
@@ -138,6 +152,8 @@ export class Point {
         this.zero();
         return this;
     }
+    // ------------------------------------------
+    // Display functions
 
     middleOf = (P1: Point, P2: Point): Point => {
         this._x = P1.x.clone().add(P2.x).divide(2);
@@ -146,17 +162,6 @@ export class Point {
         return this;
     }
     // ------------------------------------------
-    // Display functions
-    // ------------------------------------------
-    texValues = (numberOfDigits: number): string => {
-        let pts = [];
-
-        pts.push(this._x.value.toFixed(numberOfDigits === undefined ? 2 : numberOfDigits));
-        pts.push(this._y.value.toFixed(numberOfDigits === undefined ? 2 : numberOfDigits));
-
-        return `\\left(${pts.join(';')}\\right)`
-    }
-    // ------------------------------------------
     // Mathematical operations
     // ------------------------------------------
 
@@ -166,36 +171,45 @@ export class Point {
 
     // ------------------------------------------
     // Static functions
+
+    translate = (value: { x: number | Fraction, y: number | Fraction }): Point => {
+        this._x = this._x.add(value.x)
+        this._y = this._y.add(value.y)
+        return this
+    }
+
     // ------------------------------------------
-    static pmatrix = (a: any, b: any, c?: any): string => {
-        if (c === undefined) {
-            return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\end{pmatrix}`;
-        } else {
-            return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\\\ ${c.tex ? c.tex : c} \\end{pmatrix}`;
-        }
-    };
+    texValues = (numberOfDigits: number): string => {
+        let pts = [];
+
+        pts.push(this._x.value.toFixed(numberOfDigits === undefined ? 2 : numberOfDigits));
+        pts.push(this._y.value.toFixed(numberOfDigits === undefined ? 2 : numberOfDigits));
+
+        return `\\left(${pts.join(';')}\\right)`
+    }
 
-    distanceTo = (item:Point|Line): { value: number, fraction: Fraction, tex: string } => {
+    distanceTo = (item: Point | Line): { value: number, fraction: Fraction, tex: string } => {
         let value = 0, fraction = new Fraction(), tex = ''
 
-        if(item instanceof Line){
+        if (item instanceof Line) {
             return item.distanceTo(this)
-        }else if(item instanceof Point){
+        } else if (item instanceof Point) {
             let V = new Vector(this, item)
 
             value = V.norm
             fraction = V.normSquare.sqrt()
             tex = V.normSquare.isSquare() ? fraction.tex : `\\sqrt{\\frac{ ${V.normSquare.numerator} }{ ${V.normSquare.denominator} }}`
         }
-        return { value, fraction, tex }
+        return {value, fraction, tex}
     }
 
-    get key(): string {
-      return `${this.x.display};${this.y.display}`
-}
     isInListOfPoints = (list: Point[]): boolean => {
-        const keyList = list.map(x=>x.key)
+        const keyList = list.map(x => x.key)
 
         return keyList.includes(this.key)
     }
+
+    isEqual = (pt: Point): boolean => {
+        return this.x.isEqual(pt.x) && this.y.isEqual(pt.y)
+    }
 }