pimath 0.0.76 → 0.0.79

package/dist/pi.js

@@ -2542,6 +2542,23 @@ class Polynom {
         };
         // ------------------------------------------
         // Compare functions
+        this.isReduced = (polynomString) => {
+            // The polynom must be developed to be reduced.
+            if (!this.isDeveloped(polynomString)) {
+                return false;
+            }
+            let P = new Polynom(polynomString);
+            if (P.monoms.length > this.monoms.length) {
+                return false;
+            }
+            // TODO: Not ur the reduced systme checking is working properly !
+            for (let m of P.monoms) {
+                if (!m.coefficient.isReduced()) {
+                    return false;
+                }
+            }
+            return false;
+        };
         this.isDeveloped = (polynomString) => {
             let P;
             // There is at least one parenthese - it is not developed.
@@ -3174,6 +3191,38 @@ class Polynom {
         }
         return tex;
     }
+    get texDisplay() {
+        this.factorize();
+        if (this.factors.length <= 1) {
+            return this.display;
+        }
+        // Build an array of texFactors with the number of similar items.
+        let factorsCount = {};
+        for (let f of this.factors) {
+            if (factorsCount[f.display] !== undefined) {
+                factorsCount[f.display].degree++;
+            }
+            else {
+                factorsCount[f.display] = {
+                    degree: 1,
+                    factor: f
+                };
+            }
+        }
+        // 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 display = simpleFactor.isOne() ? '' : simpleFactor.display;
+        // 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) {
+                display += `\\left( ${item.factor.display} \\right)${item.degree > 1 ? '^{ ' + item.degree + ' }' : ''}`;
+            }
+        }
+        return display;
+    }
     get length() {
         // TODO: Must reduce the monoms list to remove the zero coefficient.
         return this._monoms.length;
@@ -4063,7 +4112,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);
@@ -6523,6 +6574,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;
 
@@ -6589,7 +6692,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 = {}));