pimath 0.0.104 → 0.0.106

package/dist/pi.js

@@ -2495,10 +2495,23 @@ class Polynom {
             else if (typeof value === 'number' && Number.isSafeInteger(value)) {
                 return this.divideByInteger(value);
             }
+            else if (value instanceof monom_1.Monom) {
+                return this.divide(new Polynom(value));
+            }
             else if (value instanceof Polynom) {
                 if (value.monoms.length === 1 && value.variables.length === 0) {
                     return this.divideByFraction(value.monoms[0].coefficient);
                 }
+                else {
+                    let { quotient, reminder } = this.euclidian(value);
+                    if (reminder.isZero()) {
+                        return quotient;
+                    }
+                    else {
+                        console.log(`${this.tex} is not divideable by ${value.tex}`);
+                        return new Polynom().zero();
+                    }
+                }
             }
         };
         this.pow = (nb) => {
@@ -2568,7 +2581,7 @@ class Polynom {
         this.isOpposedAt = (P) => {
             return this.compare(P.clone().opposed(), '=');
         };
-        this.isFactorized = (polynomString) => {
+        this.isFactorized = (polynomString, soft) => {
             let P;
             // Check if polynom is complete...
             if (polynomString.split('(').length !== polynomString.split(')').length) {
@@ -2590,44 +2603,67 @@ class Polynom {
             let polynomStringNormalized = polynomString.replaceAll('*', ''), polynomStringReduced = '' + polynomStringNormalized, factors = [];
             for (let x of polynomStringNormalized.matchAll(/\(([a-z0-9+\-]+)\)(\^[0-9]*)?/g)) {
                 if (x[2] !== undefined) {
+                    // if there is an exponential value, add it multiple times
                     for (let i = 0; i < +x[2].substring(1); i++) {
                         factors.push(x[1]);
                     }
                 }
                 else {
+                    // no power - add it once.
                     factors.push(x[1]);
                 }
+                // Remove the current polynom
                 polynomStringReduced = polynomStringReduced.replaceAll(x[0], '');
             }
             if (polynomStringReduced !== '') {
                 factors.push(polynomStringReduced);
             }
             let polyFactors = factors.map(x => new Polynom(x));
+            // polyFactors contain all polynoms.
+            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());
+                let FactorizedConstant = new fraction_1.Fraction().one();
+                for (let p of checkPolyFactors) {
+                    let k = p.commonMonom(), pFactor = p.clone().divide(k);
+                    if (k.degree().isZero()) {
+                        FactorizedConstant.multiply(k.coefficient);
+                        polyFactors.push(pFactor.clone());
+                    }
+                }
+            }
             // Factorize the current polynom.
             this.factorize();
-            // console.log('RESULT BEFORE COMPARE')
-            // console.log(polynomString, polynomStringNormalized)
-            // console.log(factors)
-            // console.log(this.factors.map(x=>x.display))
             // Compare the given factors with the generated factors
-            let sign = 1;
+            let sign = 1, notFoundedFactors = [];
             for (let f of this.factors) {
+                // The factor is just a coefficient. Might be opposed
                 if (f.degree().isZero()) {
                     if (f.monoms[0].coefficient.isNegativeOne()) {
                         sign = -sign;
                     }
                 }
+                let factorFound = false;
                 for (let i = 0; i < polyFactors.length; i++) {
                     if (f.isEqual(polyFactors[i])) {
                         polyFactors.splice(i, 1);
+                        factorFound = true;
                         break;
                     }
                     else if (f.isOpposedAt(polyFactors[i])) {
                         polyFactors.splice(i, 1);
                         sign = -sign;
+                        factorFound = true;
                         break;
                     }
                 }
+                if (!factorFound) {
+                    notFoundedFactors.push(f.clone());
+                }
             }
             // The polyfactors must be empty and the cumulative opposite factors must be 1.
             return (polyFactors.length === 0 && sign === 1);
@@ -4954,7 +4990,7 @@ const fraction_1 = __webpack_require__(506);
 class NumExp {
     constructor(value, uniformize) {
         this._expression = value;
-        this._rpn = new shutingyard_1.Shutingyard(shutingyard_1.ShutingyardMode.NUMERIC).parse(value).rpn;
+        this._rpn = new shutingyard_1.Shutingyard(shutingyard_1.ShutingyardMode.NUMERIC).parse(value, uniformize).rpn;
     }
     get rpn() {
         return this._rpn;
@@ -7572,78 +7608,92 @@ class Shutingyard {
         // add the last token
         return normalizedExpr + nextToken;
     }
-    /**
-     * Sanitize an expression by adding missing common operation (multiplication between parentheseses)
-     * @param expr
-     * @constructor
-     */
-    Uniformizer(expr) {
-        // TODO: Delete this old version
-        // Prefere "normalize", much more robust !
-        // Determiner if need to be uniformized
-        if (!this._uniformize) {
-            return expr;
-        }
-        // Generate the list of function token.
-        let fnToken = [];
-        for (let token in this._tokenConfig) {
-            if (this._tokenConfig[token].type === ShutingyardType.FUNCTION) {
-                fnToken.push(token);
-            }
-        }
-        // sort if from the lengthy to the smallest function
-        fnToken.sort((a, b) => b.length - a.length);
-        let tokenRegExp = new RegExp(`(${fnToken.join('|')})`, 'g');
-        let functionTokenOrder = Array.from(expr.matchAll(tokenRegExp));
-        let expr2;
-        // Replace all function by @
-        expr2 = expr.replace(tokenRegExp, '@');
-        // Add * before @ (functionn)
-        expr2 = expr2.replace(/([\da-zA-Z])(@)/g, "$1*$2");
-        // Replace missing multiplication between two parenthese
-        expr2 = expr2.replace(/\)\(/g, ')*(');
-        // Replace missing multiplication between number or setLetter and parenthese.
-        // 3x(x-4) => 3x*(x-4)
-        expr2 = expr2.replace(/([\da-zA-Z])(\()/g, "$1*$2");
-        // (x-4)3x => (x-4)*3x
-        expr2 = expr2.replace(/(\))([\da-zA-Z])/g, "$1*$2");
-        // Add multiplication between number and letters.
-        // 3x => 3*x
-        expr2 = expr2.replace(/([0-9])([a-zA-Z])/g, "$1*$2");
-        expr2 = expr2.replace(/([a-zA-Z])([0-9])/g, "$1*$2");
-        // Remove letter between function token and it's parenthese.
-        // for (let token of fnToken) {
-        //     // Remove
-        //     expr2 = expr2.replace(new RegExp(token + '\\*', 'g'), token);
-        // }
-        // Add multiplication between letters ?
-        expr2 = expr2.replace(/([a-zA-Z])([a-zA-Z])/g, "$1*$2");
-        expr2 = expr2.replace(/([a-zA-Z])([a-zA-Z])/g, "$1*$2");
-        // Restore operation auto formatting (prevent adding the multiplication star)
-        let exprAsArray = expr2.split('@');
-        if (exprAsArray.length > 0) {
-            expr2 = "";
-            for (let idx in exprAsArray) {
-            }
-            for (let token of fnToken) {
-                // Remove
-                // expr2 = expr2.replace(new RegExp(token + '\\*', 'g'), token);
-            }
-        }
-        return expr2;
-    }
+    // /**
+    //  * Sanitize an expression by adding missing common operation (multiplication between parentheseses)
+    //  * @param expr
+    //  * @constructor
+    //  */
+    // Uniformizer(expr: string): string {
+    //     // TODO: Delete this old version
+    //     // Prefere "normalize", much more robust !
+    //     // Determiner if need to be uniformized
+    //     if (!this._uniformize) {
+    //         return expr
+    //     }
+    //
+    //     // Generate the list of function token.
+    //     let fnToken: string[] = []
+    //     for (let token in this._tokenConfig) {
+    //         if (this._tokenConfig[token].type === ShutingyardType.FUNCTION) {
+    //             fnToken.push(token)
+    //         }
+    //     }
+    //     // sort if from the lengthy to the smallest function
+    //     fnToken.sort((a, b) => b.length - a.length)
+    //     let tokenRegExp = new RegExp(`(${fnToken.join('|')})`, 'g')
+    //     let functionTokenOrder = Array.from(expr.matchAll(tokenRegExp))
+    //
+    //
+    //     let expr2;
+    //
+    //     // Replace all function by @
+    //     expr2 = expr.replace(tokenRegExp, '@')
+    //     // Add * before @ (functionn)
+    //     expr2 = expr2.replace(/([\da-zA-Z])(@)/g, "$1*$2");
+    //
+    //     // Replace missing multiplication between two parenthese
+    //     expr2 = expr2.replace(/\)\(/g, ')*(');
+    //
+    //     // Replace missing multiplication between number or setLetter and parenthese.
+    //
+    //     // 3x(x-4) => 3x*(x-4)
+    //     expr2 = expr2.replace(/([\da-zA-Z])(\()/g, "$1*$2");
+    //
+    //     // (x-4)3x => (x-4)*3x
+    //     expr2 = expr2.replace(/(\))([\da-zA-Z])/g, "$1*$2");
+    //
+    //     // Add multiplication between number and letters.
+    //     // 3x => 3*x
+    //     expr2 = expr2.replace(/([0-9])([a-zA-Z])/g, "$1*$2");
+    //     expr2 = expr2.replace(/([a-zA-Z])([0-9])/g, "$1*$2");
+    //
+    //     // Remove letter between function token and it's parenthese.
+    //     // for (let token of fnToken) {
+    //     //     // Remove
+    //     //     expr2 = expr2.replace(new RegExp(token + '\\*', 'g'), token);
+    //     // }
+    //     // Add multiplication between letters ?
+    //     expr2 = expr2.replace(/([a-zA-Z])([a-zA-Z])/g, "$1*$2");
+    //     expr2 = expr2.replace(/([a-zA-Z])([a-zA-Z])/g, "$1*$2");
+    //
+    //     // Restore operation auto formatting (prevent adding the multiplication star)
+    //     let exprAsArray = expr2.split('@')
+    //
+    //     if (exprAsArray.length > 0) {
+    //         expr2 = ""
+    //         for (let idx in exprAsArray) {
+    //         }
+    //         for (let token of fnToken) {
+    //             // Remove
+    //
+    //             // expr2 = expr2.replace(new RegExp(token + '\\*', 'g'), token);
+    //         }
+    //     }
+    //
+    //     return expr2;
+    // }
     /**
      * Parse an expression using the shutting yard tree algorithms
      * @param expr (string) Expression to analyse
      * Returns a RPN list of items.
-     * @param operators
+     * @param uniformize
      */
-    parse(expr, operators) {
+    parse(expr, uniformize) {
         let outQueue = [], // Output queue
         opStack = [], // Operation queue
         token = '', tokenPos = 0, tokenType = '', previousOpStatckLength = 0;
         // Normalize the input if required.
-        if (this._uniformize)
+        if (uniformize || this._uniformize)
             expr = this.normalize(expr);
         let securityLoopLvl1 = 50, securityLoopLvl2_default = 50, securityLoopLvl2;
         while (tokenPos < expr.length) {