pimath 0.0.53 → 0.0.56

package/.eslintrc.js

@@ -1,24 +1,24 @@
-module.exports = {
-    "env": {
-        "browser": true,
-        "es6": true
-    },
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/eslint-recommended"
-    ],
-    "globals": {
-        "Atomics": "readonly",
-        "SharedArrayBuffer": "readonly"
-    },
-    "parser": "@typescript-eslint/parser",
-    "parserOptions": {
-        "ecmaVersion": 2018,
-        "sourceType": "module"
-    },
-    "plugins": [
-        "@typescript-eslint"
-    ],
-    "rules": {
-    }
+module.exports = {
+    "env": {
+        "browser": true,
+        "es6": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/eslint-recommended"
+    ],
+    "globals": {
+        "Atomics": "readonly",
+        "SharedArrayBuffer": "readonly"
+    },
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": 2018,
+        "sourceType": "module"
+    },
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "rules": {
+    }
 };

package/dist/pi.js

@@ -1276,6 +1276,50 @@ class Monom {
             }
             return this;
         };
+        this.addToken = (stack, element) => {
+            let q1, q2, m, letter, pow;
+            if (element.tokenType === shutingyard_1.ShutingyardType.COEFFICIENT) {
+                stack.push(new Monom(new fraction_1.Fraction(element.token)));
+            }
+            else if (element.tokenType === shutingyard_1.ShutingyardType.VARIABLE) {
+                let M = new Monom().one();
+                M.setLetter(element.token, 1);
+                stack.push(M.clone());
+            }
+            else if (element.tokenType === shutingyard_1.ShutingyardType.OPERATION) {
+                switch (element.token) {
+                    case '-':
+                        // this should only happen for negative powers or for negative coefficient.
+                        q2 = (stack.pop()) || new Monom().zero();
+                        q1 = (stack.pop()) || new Monom().zero();
+                        stack.push(q1.subtract(q2));
+                        break;
+                    case '*':
+                        // Get the last element in the stack
+                        q2 = (stack.pop()) || new Monom().one();
+                        q1 = (stack.pop()) || new Monom().one();
+                        stack.push(q1.multiply(q2));
+                        break;
+                    case '/':
+                        // Get the last element in the stack
+                        q2 = (stack.pop()) || new Monom().one();
+                        q1 = (stack.pop()) || new Monom().one();
+                        stack.push(q1.divide(q2));
+                        break;
+                    case '^':
+                        // get the two last elements in the stack
+                        pow = (stack.pop().coefficient) || new fraction_1.Fraction().one();
+                        m = (stack.pop()) || new Monom().one();
+                        letter = m.variables[0];
+                        if (letter !== undefined) {
+                            m.setLetter(letter, pow);
+                        }
+                        stack.push(m);
+                        // this.multiply(m.clone())
+                        break;
+                }
+            }
+        };
         this._shutingYardToReducedMonom = (inputStr) => {
             // Get the RPN array of the current expression
             const SY = new shutingyard_1.Shutingyard().parse(inputStr);
@@ -1299,7 +1343,7 @@ class Monom {
             else {
                 // Reset the monom
                 for (const element of rpn) {
-                    Monom.addToken(stack, element);
+                    this.addToken(stack, element);
                 }
             }
             this.one();
@@ -1853,7 +1897,7 @@ class Monom {
             return [this.clone()];
         }
         // Security : do not do this if greater than 10000
-        if (this.coefficient.numerator > 10000) {
+        if (this.coefficient.numerator > 1000000) {
             return [this.clone()];
         }
         const dividers = numeric_1.Numeric.dividers(Math.abs(this.coefficient.numerator));
@@ -1978,50 +2022,6 @@ class Monom {
     }
 }
 exports.Monom = Monom;
-Monom.addToken = (stack, element) => {
-    let q1, q2, m, letter, pow;
-    if (element.tokenType === shutingyard_1.ShutingyardType.COEFFICIENT) {
-        stack.push(new Monom(new fraction_1.Fraction(element.token)));
-    }
-    else if (element.tokenType === shutingyard_1.ShutingyardType.VARIABLE) {
-        let M = new Monom().one();
-        M.setLetter(element.token, 1);
-        stack.push(M.clone());
-    }
-    else if (element.tokenType === shutingyard_1.ShutingyardType.OPERATION) {
-        switch (element.token) {
-            case '-':
-                // this should only happen for negative powers or for negative coefficient.
-                q2 = (stack.pop()) || new Monom().zero();
-                q1 = (stack.pop()) || new Monom().zero();
-                stack.push(q1.subtract(q2));
-                break;
-            case '*':
-                // Get the last element in the stack
-                q2 = (stack.pop()) || new Monom().one();
-                q1 = (stack.pop()) || new Monom().one();
-                stack.push(q1.multiply(q2));
-                break;
-            case '/':
-                // Get the last element in the stack
-                q2 = (stack.pop()) || new Monom().one();
-                q1 = (stack.pop()) || new Monom().one();
-                stack.push(q1.divide(q2));
-                break;
-            case '^':
-                // get the two last elements in the stack
-                pow = (stack.pop().coefficient) || new fraction_1.Fraction().one();
-                m = (stack.pop()) || new Monom().one();
-                letter = m.variables[0];
-                if (letter !== undefined) {
-                    m.setLetter(letter, pow);
-                }
-                stack.push(m);
-                // this.multiply(m.clone())
-                break;
-        }
-    }
-};
 // ----------------------------------------
 // Static functions
 // ----------------------------------------
@@ -2100,6 +2100,81 @@ class Polynom {
      * @param values
      */
     constructor(polynomString, ...values) {
+        this.addToken = (stack, element) => {
+            switch (element.tokenType) {
+                case shutingyard_1.ShutingyardType.COEFFICIENT:
+                    stack.push(new Polynom(element.token));
+                    break;
+                case shutingyard_1.ShutingyardType.VARIABLE:
+                    stack.push(new Polynom().add(new monom_1.Monom(element.token)));
+                    break;
+                case shutingyard_1.ShutingyardType.CONSTANT:
+                    // TODO: add constant support to Polynom parsing.
+                    console.log('Actually, not supported - will be added later !');
+                    break;
+                case shutingyard_1.ShutingyardType.OPERATION:
+                    if (stack.length >= 2) {
+                        const b = stack.pop(), a = stack.pop();
+                        if (element.token === '+') {
+                            stack.push(a.add(b));
+                        }
+                        else if (element.token === '-') {
+                            stack.push(a.subtract(b));
+                        }
+                        else if (element.token === '*') {
+                            stack.push(a.multiply(b));
+                        }
+                        else if (element.token === '/') {
+                            if (b.degree().isStrictlyPositive()) {
+                                console.log('divide by a polynom -> should create a rational polynom !');
+                            }
+                            else {
+                                stack.push(a.divide(b.monoms[0].coefficient));
+                            }
+                        }
+                        else if (element.token === '^') {
+                            if (b.degree().isStrictlyPositive()) {
+                                console.error('Cannot elevate a polynom with another polynom !');
+                            }
+                            else {
+                                if (b.monoms[0].coefficient.isRelative()) {
+                                    // Integer power
+                                    stack.push(a.pow(b.monoms[0].coefficient.value));
+                                }
+                                else {
+                                    // Only allow power if the previous polynom is only a monom, without coefficient.
+                                    if (a.monoms.length === 1 && a.monoms[0].coefficient.isOne()) {
+                                        for (let letter in a.monoms[0].literal) {
+                                            a.monoms[0].literal[letter].multiply(b.monoms[0].coefficient);
+                                        }
+                                        stack.push(a);
+                                    }
+                                    else {
+                                        console.error('Cannot have power with fraction');
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        if (element.token === '-') {
+                            stack.push(stack.pop().opposed());
+                        }
+                        else {
+                            throw "Error parsing the polynom " + this._rawString;
+                        }
+                    }
+                    break;
+                case shutingyard_1.ShutingyardType.MONOM:
+                    // Should never appear.
+                    console.error('The monom token should not appear here');
+                    break;
+                case shutingyard_1.ShutingyardType.FUNCTION:
+                    // Should never appear.
+                    console.error('The function token should not appear here - might be introduced later.');
+                    break;
+            }
+        };
         // ------------------------------------------
         /**
          * Parse a string to a polynom.
@@ -2292,9 +2367,13 @@ class Polynom {
             const letter = P.variables[0];
             const quotient = new Polynom().zero();
             const reminder = this.clone().reorder(letter);
-            // There is no variable !
+            // There is no variable - means it's a number
             if (P.variables.length === 0) {
-                return { quotient, reminder };
+                let q = this.clone().divide(P);
+                return {
+                    quotient: this.clone().divide(P),
+                    reminder: new Polynom().zero()
+                };
             }
             // Get at least a letter
             const maxMP = P.monomByDegree(undefined, letter);
@@ -2324,6 +2403,11 @@ class Polynom {
             else if (typeof value === 'number' && Number.isSafeInteger(value)) {
                 return this.divideByInteger(value);
             }
+            else if (value instanceof Polynom) {
+                if (value.monoms.length === 1 && value.variables.length === 0) {
+                    return this.divideByFraction(value.monoms[0].coefficient);
+                }
+            }
         };
         this.pow = (nb) => {
             if (!Number.isSafeInteger(nb)) {
@@ -2590,8 +2674,7 @@ class Polynom {
             let P = this.clone().reorder(), M = P.commonMonom(), tempPolynom;
             // It has a common monom.
             if (!M.isOne()) {
-                tempPolynom = new Polynom();
-                tempPolynom.monoms = [M];
+                tempPolynom = new Polynom(M);
                 factors = [tempPolynom.clone()];
                 P = P.euclidian(tempPolynom).quotient;
             }
@@ -2614,7 +2697,8 @@ class Polynom {
                 }
                 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;
+                    // 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 => {
@@ -2886,7 +2970,7 @@ class Polynom {
             let stack = [], monom = new monom_1.Monom();
             // Loop through the
             for (const element of rpn) {
-                Polynom.addToken(stack, element);
+                this.addToken(stack, element);
             }
             if (stack.length === 1) {
                 this.add(stack[0]);
@@ -3215,82 +3299,6 @@ class Polynom {
     }
 }
 exports.Polynom = Polynom;
-Polynom.addToken = (stack, element) => {
-    switch (element.tokenType) {
-        case shutingyard_1.ShutingyardType.COEFFICIENT:
-            stack.push(new Polynom(element.token));
-            break;
-        case shutingyard_1.ShutingyardType.VARIABLE:
-            stack.push(new Polynom().add(new monom_1.Monom(element.token)));
-            break;
-        case shutingyard_1.ShutingyardType.CONSTANT:
-            // TODO: add constant support to Polynom parsing.
-            console.log('Actually, not supported - will be added later !');
-            break;
-        case shutingyard_1.ShutingyardType.OPERATION:
-            if (stack.length >= 2) {
-                const b = stack.pop(), a = stack.pop();
-                if (element.token === '+') {
-                    stack.push(a.add(b));
-                }
-                else if (element.token === '-') {
-                    stack.push(a.subtract(b));
-                }
-                else if (element.token === '*') {
-                    stack.push(a.multiply(b));
-                }
-                else if (element.token === '/') {
-                    if (b.degree().isStrictlyPositive()) {
-                        console.log('divide by a polynom -> should create a rational polynom !');
-                    }
-                    else {
-                        stack.push(a.divide(b.monoms[0].coefficient));
-                    }
-                }
-                else if (element.token === '^') {
-                    if (b.degree().isStrictlyPositive()) {
-                        console.error('Cannot elevate a polynom with another polynom !');
-                    }
-                    else {
-                        if (b.monoms[0].coefficient.isRelative()) {
-                            // Integer power
-                            stack.push(a.pow(b.monoms[0].coefficient.value));
-                        }
-                        else {
-                            // Only allow power if the previous polynom is only a monom, without coefficient.
-                            if (a.monoms.length === 1 && a.monoms[0].coefficient.isOne()) {
-                                for (let letter in a.monoms[0].literal) {
-                                    a.monoms[0].literal[letter].multiply(b.monoms[0].coefficient);
-                                }
-                                stack.push(a);
-                            }
-                            else {
-                                console.error('Cannot have power with fraction');
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                console.log('Stack size: ', stack.length);
-                if (element.token === '-') {
-                    stack.push(stack.pop().opposed());
-                }
-                else {
-                    console.log('While parsing, cannot apply ', element.token, 'to', stack[0].tex);
-                }
-            }
-            break;
-        case shutingyard_1.ShutingyardType.MONOM:
-            // Should never appear.
-            console.error('The monom token should not appear here');
-            break;
-        case shutingyard_1.ShutingyardType.FUNCTION:
-            // Should never appear.
-            console.log('The function token should not appear here - might be introduced later.');
-            break;
-    }
-};
 
 
 /***/ }),