pimath 0.0.53 → 0.0.54

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();
@@ -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,82 @@ 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 {
+                            console.error('While parsing, cannot apply ', element.token, 'to', stack[0].tex);
+                            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.
@@ -2886,7 +2962,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 +3291,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;
-    }
-};
 
 
 /***/ }),