pimath 0.0.60 → 0.0.61

package/dist/pi.js

@@ -1760,6 +1760,21 @@ class Monom {
             // All checks passed.
             return true;
         };
+        this.isDivisible = (div) => {
+            // For all variables (letters), the current monom must have a degree higher than the divider
+            if (div.degree().isStrictlyPositive()) {
+                for (let letter of div.variables) {
+                    if (!this.degree(letter).geq(div.degree(letter))) {
+                        return false;
+                    }
+                }
+            }
+            // If the coefficient is rational, we suppose we don't need to check the division by the coefficient.
+            if (this.coefficient.isRational() || div.coefficient.isRational()) {
+                return true;
+            }
+            return this.coefficient.clone().divide(div.coefficient).isRelative();
+        };
         this.zero();
         if (value !== undefined) {
             // A string is given - try to parse the value.
@@ -2135,6 +2150,11 @@ class Polynom {
      * @param values
      */
     constructor(polynomString, ...values) {
+        this.mark_as_dirty = () => {
+            this.dirty_factors = true;
+            this.dirty_zeroes = true;
+            this.euclidianCache = {};
+        };
         this.addToken = (stack, element) => {
             switch (element.tokenType) {
                 case shutingyard_1.ShutingyardType.COEFFICIENT:
@@ -2222,6 +2242,7 @@ class Polynom {
             // Reset the main variables.
             this._monoms = [];
             this._factors = [];
+            this.mark_as_dirty();
             if (typeof inputStr === 'string') {
                 return this._parseString(inputStr, ...values);
             }
@@ -2262,88 +2283,32 @@ class Polynom {
             this._monoms = [];
             this._monoms.push(new monom_1.Monom().zero());
             this._rawString = '0';
+            this.mark_as_dirty();
             return this;
         };
         this.one = () => {
             this._monoms = [];
             this._monoms.push(new monom_1.Monom().one());
             this._rawString = '1';
+            this.mark_as_dirty();
             return this;
         };
         this.empty = () => {
             this._monoms = [];
             this._rawString = '';
+            this.mark_as_dirty();
             return this;
         };
         // ------------------------------------------
         this.opposed = () => {
             this._monoms = this._monoms.map(m => m.opposed());
+            this.mark_as_dirty();
             return this;
         };
-        // // -----------------------------------------------
-        // // Polynom generators and randomizers
-        // // -----------------------------------------------
-        // random(config?: randomPolynomConfig) {
-        //     return Random.polynom(config);
-        // }
-        //
-        // private _randomizeDefaults: { [key: string]: number | string | boolean } = {
-        //     degree: 2,
-        //     unit: true,
-        //     fractions: false,
-        //     factorable: false,
-        //     letters: 'x',
-        //     allowNullMonom: false,
-        //     numberOfMonoms: false
-        // };
-        // get randomizeDefaults(): { [key: string]: number | string | boolean } {
-        //     return this._randomizeDefaults;
-        // }
-        //
-        // set randomizeDefaults(value) {
-        //     this._randomizeDefaults = value;
-        // }
-        //
-        // randomize = (config: { [key: string]: number | string | boolean }): Polynom => {
-        //     let P = new Polynom();
-        //
-        //     // Check the config file and use the default values.
-        //     if (config === undefined) {
-        //         config = {};
-        //     }
-        //     for (let k in this._randomizeDefaults) {
-        //         if (config[k] === undefined) {
-        //             config[k] = this._randomizeDefaults[k];
-        //         }
-        //     }
-        //
-        //     // TODO: Build a more robust randomize function
-        //     return P;
-        // }
-        //
-        // rndFactorable = (degree: number = 2, unit: boolean | number = false, letters: string = 'x'): Polynom => {
-        //     // TODO: Make rndFactorable polynom generator more user friendly
-        //     this._factors = [];
-        //     for (let i = 0; i < degree; i++) {
-        //         let factorUnit = unit === true || i >= unit,
-        //             p = Random.polynom({
-        //                 degree: 1,
-        //                 unit: factorUnit,
-        //                 fraction: false,
-        //                 letters
-        //             });
-        //         this._factors.push(p);
-        //     }
-        //
-        //     this.empty().monoms = this._factors[0].monoms;
-        //     for (let i = 1; i < this._factors.length; i++) {
-        //         this.multiply(this._factors[i]);
-        //     }
-        //     return this;
-        // };
         // ------------------------------------------
         // Mathematical operations
         this.add = (...values) => {
+            this.mark_as_dirty();
             for (let value of values) {
                 if (value instanceof Polynom) {
                     this._monoms = this._monoms.concat(value.monoms);
@@ -2361,6 +2326,7 @@ class Polynom {
             return this.reduce();
         };
         this.subtract = (...values) => {
+            this.mark_as_dirty();
             for (let value of values) {
                 if (value instanceof Polynom) {
                     this._monoms = this._monoms.concat(value.clone().opposed().monoms);
@@ -2378,6 +2344,7 @@ class Polynom {
             return this.reduce();
         };
         this.multiply = (value) => {
+            this.mark_as_dirty();
             if (value instanceof Polynom) {
                 return this.multiplyByPolynom(value);
             }
@@ -2399,6 +2366,9 @@ class Polynom {
          * returns {quotient: Polynom, reminder: Polynom}
          */
         this.euclidian = (P) => {
+            if (this.euclidianCache[P.tex] !== undefined) {
+                return this.euclidianCache[P.tex];
+            }
             const letter = P.variables[0];
             const quotient = new Polynom().zero();
             const reminder = this.clone().reorder(letter);
@@ -2432,6 +2402,7 @@ class Polynom {
             return { quotient, reminder };
         };
         this.divide = (value) => {
+            this.mark_as_dirty();
             if (value instanceof fraction_1.Fraction) {
                 return this.divideByFraction(value);
             }
@@ -2445,6 +2416,7 @@ class Polynom {
             }
         };
         this.pow = (nb) => {
+            this.mark_as_dirty();
             if (!Number.isSafeInteger(nb)) {
                 return this.zero();
             }
@@ -2645,6 +2617,7 @@ class Polynom {
          * @param P
          */
         this.replaceBy = (letter, P) => {
+            this.mark_as_dirty();
             let pow;
             const resultPolynom = new Polynom().zero();
             for (const m of this.monoms) {
@@ -2704,146 +2677,108 @@ class Polynom {
          * @param maxValue Defines the greatest value to search to (default is 20).
          */
         this.factorize = (letter) => {
-            let factors = [];
-            // Extract the common monom
-            let P = this.clone().reorder(), M = P.commonMonom(), tempPolynom;
-            // It has a common monom.
-            if (!M.isOne()) {
-                tempPolynom = new Polynom(M);
-                factors = [tempPolynom.clone()];
-                P = P.euclidian(tempPolynom).quotient;
-            }
-            let securityLoop = P.degree().clone().multiply(2).value;
-            let result;
-            // securityLoop = 0
-            while (securityLoop >= 0) {
-                securityLoop--;
-                if (P.monoms.length < 2) {
-                    if (!P.isOne()) {
+            if (this.dirty_factors) {
+                let factors = [];
+                let P = this.clone().reorder();
+                // Extract the common monom
+                // 2x^3+6x^2 => 2x^2
+                let M = P.commonMonom();
+                if (!M.isOne()) {
+                    let tempPolynom = new Polynom(M);
+                    factors = [tempPolynom.clone()];
+                    P = P.euclidian(tempPolynom).quotient;
+                }
+                // Main loop
+                let securityLoop = P.degree().clone().multiply(2).value, maxDegree = 1;
+                while (securityLoop >= 0) {
+                    securityLoop--;
+                    if (P.monoms.length < 2) {
+                        // The polynom has only one monom => 7x^2
+                        // No need to continue.
+                        if (!P.isOne()) {
+                            factors.push(P.clone());
+                            P.one();
+                        }
+                        break;
+                    }
+                    else if (P.degree(letter).isOne()) {
+                        // The polynom is a first degree polynom => 3x-5
+                        // No need to continue
                         factors.push(P.clone());
                         P.one();
+                        break;
+                    }
+                    else {
+                        // Create the list of all "potential" polynom dividers.
+                        let allDividers = this._getAllPotentialFactors(P, maxDegree, letter);
+                        maxDegree = P.degree(letter).value;
+                        // Actually: 100ms
+                        while (allDividers.length > 0) {
+                            let div = allDividers[0];
+                            if (!P.isDividableBy(div)) {
+                                // Not dividable. Remove it from the list
+                                allDividers.shift();
+                            }
+                            else {
+                                // Add the factor
+                                factors.push(div);
+                                // It's dividable - so make the division
+                                let result = P.euclidian(div);
+                                // As it's dividable, get the quotient.
+                                P = result.quotient.clone();
+                                // filter all dividers that are no more suitable.
+                                allDividers = allDividers.filter(x => {
+                                    let pX = P.monoms[0], pC = P.monoms[P.monoms.length - 1], dX = x.monoms[0], dC = x.monoms[x.monoms.length - 1];
+                                    // Check last item (degree zero)
+                                    if (!pC.isDivisible(dC)) {
+                                        return false;
+                                    }
+                                    // Check the first item (degree max)
+                                    if (!pX.isDivisible(dX)) {
+                                        return false;
+                                    }
+                                    return true;
+                                });
+                            }
+                        }
                     }
-                    break;
                 }
-                else if (P.degree(letter).isOne()) {
+                // Maybe there is still something in the Polynom (not everything was possible to factorize)
+                if (!P.isOne()) {
                     factors.push(P.clone());
-                    P.one();
-                    break;
+                }
+                // Save the factors
+                this.factors = factors;
+                // The factors list is no more dirty
+                this.dirty_factors = false;
+            }
+            return this.factors;
+        };
+        this.isDividableBy = (div) => {
+            // Quick evaluation.
+            if (div.degree().isOne()) {
+                let zero = div.getZeroes()[0];
+                if (zero.exact instanceof fraction_1.Fraction) {
+                    return this.evaluate(zero.exact).isZero();
                 }
                 else {
-                    // Get the first and last monom and build all their dividers.
-                    // let m1 = P.monoms[0].dividers,
-                    //     m2 = P.monoms[P.monoms.length - 1].dividers
-                    // Create the list of all "potential" polynom dividers.
-                    let allDividers = this._getAllPotentialFactors(P, letter);
-                    allDividers.every(div => {
-                        result = P.euclidian(div);
-                        if (result.reminder.isZero()) {
-                            P = result.quotient.clone();
-                            factors.push(div);
-                            return false;
-                        }
-                        return true;
-                    });
+                    return false;
                 }
             }
-            if (!P.isOne()) {
-                factors.push(P.clone());
+            else {
+                this.euclidianCache[div.tex] = this.euclidian(div);
+                return this.euclidianCache[div.tex].reminder.isZero();
             }
-            this.factors = factors;
-            return factors;
         };
         // TODO: get zeroes for more than first degree and for more than natural degrees
         this.getZeroes = () => {
-            let equ = new equation_1.Equation(this.clone(), 0);
-            equ.solve();
-            return equ.solutions;
-            //
-            // const Z: Fraction[] = [];
-            //
-            // // ISolution: {tex: string, value: number, exact: boolean|Fraction|...}
-            //
-            // switch (this.degree().value) {
-            //     case 0:
-            //         if (this._monoms[0].coefficient.value === 0) {
-            //             return [{
-            //                 tex: '\\mathbb{R}',
-            //                 value: NaN,
-            //                 exact: false
-            //             }];
-            //         } else {
-            //             return [{
-            //                 tex: '\\varnothing',
-            //                 value: NaN,
-            //                 exact: false
-            //             }];
-            //         }
-            //     case 1:
-            //         // There is only one monoms,
-            //         if (this._monoms.length === 1) {
-            //             return [{
-            //                 tex: '0',
-            //                 value: 0,
-            //                 exact: new Fraction().zero()
-            //             }];
-            //         } else {
-            //             const P = this.clone().reduce().reorder();
-            //             const coeff = P.monoms[1].coefficient.opposed().divide(P.monoms[0].coefficient)
-            //             return [{
-            //                 tex: coeff.tex,
-            //                 value: coeff.value,
-            //                 exact: coeff
-            //             }];
-            //         }
-            //     // TODO: Determine the zeros of an equation of second degree.
-            //     //case 2:
-            //     default:
-            //         // Make sure the polynom is factorized.
-            //         if (this._factors.length === 0) {
-            //             this.factorize()
-            //         }
-            //
-            //         let zeroes:Fraction[] = [], zeroesAsTex = [];
-            //         for (let P of this._factors) {
-            //             if (P.degree().greater(2)) {
-            //                 // TODO: get zeroes of polynom with a degree greater than 2.
-            //
-            //             } else if (P.degree().value === 2) {
-            //                 let A = P.monomByDegree(2).coefficient,
-            //                     B = P.monomByDegree(1).coefficient,
-            //                     C = P.monomByDegree(0).coefficient,
-            //                     D = B.clone().pow(2).subtract(A.clone().multiply(C).multiply(4));
-            //
-            //                 if (D.value > 0) {
-            //                     /*console.log('Two zeroes for ', P.tex); */
-            //                     let x1 = (-(B.value) + Math.sqrt(D.value)) / (2 * A.value),
-            //                         x2 = (-(B.value) - Math.sqrt(D.value)) / (2 * A.value);
-            //
-            //                     zeroes.push(new Fraction(x1.toFixed(3)).reduce());
-            //                     zeroes.push(new Fraction(x2.toFixed(3)).reduce());
-            //                 } else if (D.value === 0) {
-            //                     /*console.log('One zero for ', P.tex); */
-            //                 } else {
-            //                     console.log('No zero for ', P.tex);
-            //                 }
-            //             } else {
-            //                 for (let z of P.getZeroes()) {
-            //                     // Check if the zero is already in the list.
-            //                     // if (z === false || z === true) {
-            //                     //     continue;
-            //                     // }
-            //                     if (zeroesAsTex.indexOf(z.frac) === -1) {
-            //                         zeroes.push(z);
-            //                         zeroesAsTex.push(z.frac);
-            //                     }
-            //                 }
-            //             }
-            //         }
-            //
-            //
-            //         return zeroes;
-            // }
-            // return Z;
+            if (this.dirty_zeroes) {
+                let equ = new equation_1.Equation(this.clone(), 0);
+                equ.solve();
+                this._zeroes = equ.solutions;
+                this.dirty_zeroes = false;
+            }
+            return this._zeroes;
         };
         // TODO: analyse the next functions to determine if they are useful or not...
         this.monomByDegree = (degree, letter) => {
@@ -2958,16 +2893,19 @@ class Polynom {
             // Any other cases
             return (new fraction_1.Fraction()).zero();
         };
-        this._getAllPotentialFactors = (P, letter) => {
+        this._getAllPotentialFactors = (P, maxDegree, letter) => {
             let m1 = P.monoms[0].dividers, m2 = P.monoms[P.monoms.length - 1].dividers;
             let allDividers = [];
             m1.forEach(m1d => {
-                m2.forEach(m2d => {
-                    if (m1d.degree(letter).isNotEqual(m2d.degree(letter))) {
-                        allDividers.push(new Polynom(m1d, m2d));
-                        allDividers.push(new Polynom(m1d, m2d.clone().opposed()));
-                    }
-                });
+                // Get only polynom that has a degree less than a specific value
+                if (m1d.degree(letter).leq(maxDegree)) {
+                    m2.forEach(m2d => {
+                        if (m1d.degree(letter).isNotEqual(m2d.degree(letter))) {
+                            allDividers.push(new Polynom(m1d, m2d));
+                            allDividers.push(new Polynom(m1d, m2d.clone().opposed()));
+                        }
+                    });
+                }
             });
             return allDividers;
         };
@@ -3019,41 +2957,6 @@ class Polynom {
                 this.add(stack[0]);
             }
             return this;
-            /**
-             let m1: Polynom;
-             let m2: Polynom;
-    
-             let stack: Polynom[] = [],
-             previousToken: string = null,
-             tempPolynom
-    
-             for (const element of rpn) {
-                if (element.tokenType === 'coefficient' || element.tokenType === 'variable') {
-                    tempPolynom = new Polynom().zero();
-                    tempPolynom.monoms = [new Monom(element.token)]
-                    stack.push(tempPolynom.clone())
-                } else if (element.tokenType === 'operation') {
-                    m2 = (stack.pop()) || new Polynom().zero();
-                    m1 = (stack.pop()) || new Polynom().zero();
-                    switch (element.token) {
-                        case '+':
-                            stack.push(m1.add(m2))
-                            break;
-                        case '-':
-                            stack.push(m1.subtract(m2))
-                            break;
-                        case '*':
-                            stack.push(m1.multiply(m2))
-                            break;
-                        case '^':
-                            stack.push(m1.pow(+previousToken))
-                    }
-                }
-                previousToken = element.token;
-            }
-    
-             this._monoms = stack[0].monoms;
-             return this;*/
         };
         this.multiplyByPolynom = (P) => {
             const M = [];
@@ -3178,33 +3081,6 @@ class Polynom {
                     }
                 }
                 return [this.clone()];
-                //
-                // console.log(a.tex, b.tex, c.tex)
-                // if (a.isSquare() && c.isSquare()) {
-                //     console.log('A C squares')
-                //     if (a.clone().sqrt().multiply(c.clone().sqrt()).multiplyByNumber(2).isSameAs(b)) {
-                //         console.log('HERE')
-                //         if (a.coefficient.sign() === b.coefficient.sign()) {
-                //             return []
-                //         }else{
-                //             return []
-                //         }
-                //     }
-                // } else if(a.isLiteralSquare() && c.isLiteralSquare()) {
-                //     console.log('A C litteral SQUARES')
-                //     // Check that the middle element is the product of a and c.
-                //
-                //     if(b.clone().pow(2).isSameAs(a.clone().multiply(c))){
-                //         console.log('SAME')
-                //
-                //     }else{
-                //         console.log('NOT SAME')
-                //     }
-                //
-                //     return [this.clone()]
-                // } else {
-                //     console.log('NOT SQUARES AT ALL !!!!')
-                // }
             }
         };
         this._factorizeByGroups = () => {
@@ -3213,11 +3089,31 @@ class Polynom {
         };
         this._monoms = [];
         this._factors = [];
+        this.mark_as_dirty();
         if (polynomString !== undefined) {
             this.parse(polynomString, ...values);
         }
         return this;
     }
+    get euclidianCache() {
+        return this._euclidianCache;
+    }
+    set euclidianCache(value) {
+        this._euclidianCache = value;
+    }
+    get dirty_zeroes() {
+        return this._dirty_zeroes;
+    }
+    set dirty_zeroes(value) {
+        this._dirty_zeroes = value;
+    }
+    // ------------------------------------------
+    get dirty_factors() {
+        return this._dirty_factors;
+    }
+    set dirty_factors(value) {
+        this._dirty_factors = value;
+    }
     // ------------------------------------------
     get monoms() {
         return this._monoms;
@@ -3225,10 +3121,14 @@ class Polynom {
     set monoms(M) {
         this._monoms = M;
     }
+    get zeroes() {
+        return this.getZeroes();
+    }
     get factors() {
         return this._factors;
     }
     set factors(value) {
+        this.mark_as_dirty();
         this._factors = value;
     }
     get texString() {