pimath 0.0.75 → 0.0.78

package/dist/pi.js

@@ -2680,81 +2680,86 @@ class Polynom {
          * @param maxValue Defines the greatest value to search to (default is 20).
          */
         this.factorize = (letter) => {
-            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
+            if (!this.dirty_factors) {
+                return this._factors;
+            }
+            let factors = [];
+            let P = this.clone().reorder();
+            // Extract the common monom
+            // 2x^3+6x^2 => 2x^2
+            let M = P.commonMonom();
+            // If the polynom starts with a negative monom, factorize it.
+            if (P.monomByDegree().coefficient.isStrictlyNegative() && M.coefficient.isStrictlyPositive()) {
+                M.opposed();
+            }
+            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 {
-                        // 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 {
-                                // It's dividable - so make the division
-                                let result = P.euclidian(div);
-                                // Add the factor
-                                factors.push(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;
                 }
-                // Maybe there is still something in the Polynom (not everything was possible to factorize)
-                if (!P.isOne()) {
+                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 {
+                            // It's dividable - so make the division
+                            let result = P.euclidian(div);
+                            // Add the factor
+                            factors.push(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;
+                            });
+                        }
+                    }
                 }
-                // Save the factors
-                this._factors = factors;
-                // The factors list is no more dirty
-                this.dirty_factors = false;
             }
+            // Maybe there is still something in the Polynom (not everything was possible to factorize)
+            if (!P.isOne()) {
+                factors.push(P.clone());
+            }
+            // Save the factors
+            this._factors = factors;
+            // The factors list is no more dirty
+            this.dirty_factors = false;
             return this._factors;
         };
         this.isDividableBy = (div) => {
@@ -3142,7 +3147,6 @@ class Polynom {
         if (this.factors.length <= 1) {
             return this.tex;
         }
-        let tex = '';
         // Build an array of texFactors with the number of similar items.
         let factorsCount = {};
         for (let f of this.factors) {
@@ -3156,23 +3160,18 @@ class Polynom {
                 };
             }
         }
-        for (let item of Object.values(factorsCount)) {
+        // First round to put the 'monom' first
+        let simpleFactor = new Polynom().one();
+        for (let item of Object.values(factorsCount).filter(item => item.factor.monoms.length === 1)) {
+            simpleFactor.multiply(item.factor);
+        }
+        let tex = simpleFactor.isOne() ? '' : simpleFactor.tex;
+        // Loop through all factors that contains at least 2 monoms.
+        for (let item of Object.values(factorsCount).filter(item => item.factor.monoms.length > 1)) {
             if (item.factor.length > 1) {
                 tex += `\\left( ${item.factor.tex} \\right)${item.degree > 1 ? '^{ ' + item.degree + ' }' : ''}`;
             }
-            else {
-                tex += item.degree === 1 ? item.factor.tex : `\\left( ${item.factor} \\right^{ ${item.degree} }`;
-            }
         }
-        //
-        // // Actual system
-        // for (let f of this.factors) {
-        //     if (f.monoms.length > 1) {
-        //         tex += `(${f.tex})`
-        //     } else {
-        //         tex = f.tex + tex;
-        //     }
-        // }
         return tex;
     }
     get length() {
@@ -4064,7 +4063,9 @@ class Fraction {
                     else {
                         // The given value is a float number
                         // Get the number of decimals after the float sign
-                        let p = (value.toString()).split('.')[1].length;
+                        let [unit, decimal] = (value.toString()).split('.');
+                        let p = decimal.length;
+                        // Detect if the decimal part is periodic or not...
                         // Transform the float number in two integer
                         if (denominatorOrPeriodic === undefined) {
                             this._numerator = value * Math.pow(10, p);
@@ -6524,6 +6525,58 @@ class Numeric {
         }
         return triplets;
     }
+    static numberCorrection(value) {
+        // Must modify the number if it's like:
+        // a: 3.0000000000000003
+        // b: 3.9999999999999994
+        // remove the last character
+        // check if around n last characters are either 0 or 9
+        // if it is, 'round' the number.
+        function extractDecimalPart(valueToExtract) {
+            let decimal = valueToExtract.toString();
+            if (!decimal.includes('.')) {
+                return '';
+            }
+            decimal = decimal.split('.')[1];
+            return decimal.substring(0, decimal.length - 2);
+        }
+        const epsilon = 0.00000000000001, number_of_digits = 6;
+        const decimal = extractDecimalPart(value);
+        if (decimal === '') {
+            return value;
+        }
+        const n9 = decimal.match(/9+$/g);
+        const n0 = decimal.match(/0+$/g);
+        if (n9 && n9[0].length >= number_of_digits) {
+            // New tested values.
+            const mod = extractDecimalPart(value + epsilon), mod0 = mod.match(/0+$/g);
+            if (mod0 && mod0[0].length >= number_of_digits) {
+                // The value can be changed. Remove all zeros!
+                return +((value + epsilon).toString().split(mod0[0])[0]);
+            }
+        }
+        if (n0 && n0[0].length >= number_of_digits) {
+            // New tested values.
+            const mod = extractDecimalPart(value - epsilon), mod9 = mod.match(/9+$/g);
+            if (mod9 && mod9[0].length >= number_of_digits) {
+                // The value can be changed. Remove all nines!
+                return +(value.toString().split(n0[0])[0]);
+            }
+        }
+        return value;
+    }
+    static periodic(value) {
+        if (Number.isSafeInteger(value)) {
+            return 0;
+        }
+        // Assume it's with decimal.
+        let decimal = (value.toString()).split('.')[0];
+        // The decimal part is limited
+        if (decimal.length < 10) {
+            return 0;
+        }
+        // Find the periodic if it exists.
+    }
 }
 exports.Numeric = Numeric;
 
@@ -6590,7 +6643,7 @@ var Random;
     }
     Random.item = item;
     function shuffle(arr) {
-        rndHelpers_1.rndHelpers.shuffleArray(arr);
+        return rndHelpers_1.rndHelpers.shuffleArray(arr);
     }
     Random.shuffle = shuffle;
 })(Random = exports.Random || (exports.Random = {}));