pimath 0.0.66 → 0.0.67

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

@@ -434,10 +434,10 @@ class Equation {
                 else {
                     // Must handle the case if the m1 monom is negative.
                     if ((this.isGreater() && m1.sign() === 1) || (!this.isGreater() && m1.sign() === -1)) {
-                        s = `\\left${this.isAlsoEqual() ? '\\[' : '\\]'}${v};+\\infty\\right\\[`;
+                        s = `\\left${this.isAlsoEqual() ? '\\[' : '\\]'}${v.tex};+\\infty\\right\\[`;
                     }
                     else {
-                        s = `\\left\\]-\\infty;${v} \\right\\${this.isAlsoEqual() ? '\\]' : '\\['}`;
+                        s = `\\left\\]-\\infty;${v.tex} \\right\\${this.isAlsoEqual() ? '\\]' : '\\['}`;
                     }
                 }
                 this._solutions = [{
@@ -2245,6 +2245,7 @@ class Polynom {
             this._monoms = [];
             this._factors = [];
             this.mark_as_dirty();
+            // TODO: allow to enter a liste of Fraction (a, b, c, ...) to make a polynom ax^n + bx^(n-1) + cx^(n-2) + ...
             if (typeof inputStr === 'string') {
                 return this._parseString(inputStr, ...values);
             }
@@ -3467,9 +3468,9 @@ var FUNCTION_EXTREMA;
 })(FUNCTION_EXTREMA = exports.FUNCTION_EXTREMA || (exports.FUNCTION_EXTREMA = {}));
 var TABLE_OF_SIGNS;
 (function (TABLE_OF_SIGNS) {
-    TABLE_OF_SIGNS[TABLE_OF_SIGNS["DEFAULT"] = 0] = "DEFAULT";
-    TABLE_OF_SIGNS[TABLE_OF_SIGNS["GROWS"] = 1] = "GROWS";
-    TABLE_OF_SIGNS[TABLE_OF_SIGNS["VARIATIONS"] = 2] = "VARIATIONS";
+    TABLE_OF_SIGNS["SIGNS"] = "signs";
+    TABLE_OF_SIGNS["GROWS"] = "grows";
+    TABLE_OF_SIGNS["VARIATIONS"] = "variatins";
 })(TABLE_OF_SIGNS = exports.TABLE_OF_SIGNS || (exports.TABLE_OF_SIGNS = {}));
 /**
  * The study class is a "function study" class that will get:
@@ -3723,7 +3724,7 @@ class Study {
     ;
     makeSigns() {
         return {
-            type: TABLE_OF_SIGNS.DEFAULT,
+            type: TABLE_OF_SIGNS.SIGNS,
             fx: null,
             factors: [],
             zeroes: [],
@@ -3970,8 +3971,12 @@ const numeric_1 = __webpack_require__(956);
  */
 class Fraction {
     constructor(value, denominatorOrPeriodic) {
-        // ------------------------------------------
-        // Creation / parsing functions
+        this.isApproximative = () => {
+            return this._numerator.toString().length >= 15 && this._denominator.toString().length >= 15;
+        };
+        this.isExact = () => {
+            return !this.isApproximative();
+        };
         // ------------------------------------------
         /**
          * Parse the value to get the numerator and denominator
@@ -3988,15 +3993,15 @@ class Fraction {
             }
             switch (typeof value) {
                 case "string":
-                    // Split the sting value in two parts: Numerator/Denominator
+                    // Split the string value in two parts: Numerator/Denominator
                     S = value.split('/');
                     // Security checks
                     if (S.length > 2)
-                        throw "Two many divide signs";
+                        throw value + " has too many divide signs";
                     if (S.map(x => x === '' || isNaN(Number(x))).includes(true))
-                        throw "Not a number";
+                        throw value + " is not a valid number";
                     if (S.length === 1) {
-                        // No divide sign
+                        // No divide sign - it's a number
                         return this.parse(+S[0]);
                     }
                     else if (S.length === 2) {
@@ -4013,6 +4018,7 @@ class Fraction {
                     }
                     else {
                         // More than one divide sign ?
+                        // This is impossible
                         this._numerator = NaN;
                         this._denominator = 1;
                     }
@@ -4053,6 +4059,8 @@ class Fraction {
             }
             return this;
         };
+        // ------------------------------------------
+        // Mathematical operations
         this.clone = () => {
             let F = new Fraction();
             F.numerator = +this._numerator;
@@ -4080,8 +4088,6 @@ class Fraction {
             return this;
         };
         // ------------------------------------------
-        // Mathematical operations
-        // ------------------------------------------
         this.opposed = () => {
             this._numerator = -this._numerator;
             return this;
@@ -4360,22 +4366,32 @@ class Fraction {
         if (this.isInfinity()) {
             return `${this.sign() === 1 ? '+' : '-'}\\infty`;
         }
-        if (this._denominator === 1) {
-            return `${this._numerator}`;
-        }
-        else if (this._numerator < 0) {
-            return `-\\frac{ ${-this._numerator} }{ ${this._denominator} }`;
+        if (this.isExact()) {
+            if (this._denominator === 1) {
+                return `${this._numerator}`;
+            }
+            else if (this._numerator < 0) {
+                return `-\\frac{ ${-this._numerator} }{ ${this._denominator} }`;
+            }
+            else {
+                return `\\frac{ ${this._numerator} }{ ${this._denominator} }`;
+            }
         }
         else {
-            return `\\frac{ ${this._numerator} }{ ${this._denominator} }`;
+            return this.value.toFixed(3);
         }
     }
     get display() {
-        if (this._denominator === 1) {
-            return `${this._numerator}`;
+        if (this.isExact()) {
+            if (this._denominator === 1) {
+                return `${this._numerator}`;
+            }
+            else {
+                return `${this._numerator}/${this._denominator}`;
+            }
         }
         else {
-            return `${this._numerator}/${this._denominator}`;
+            return this.value.toFixed(3);
         }
     }
     // Helper function to display fractions
@@ -4410,6 +4426,8 @@ Fraction.min = (...fractions) => {
     }
     return M;
 };
+// ------------------------------------------
+// Creation / parsing functions
 Fraction.average = (...fractions) => {
     let M = new Fraction().zero();
     for (let f of fractions) {
@@ -6831,6 +6849,7 @@ var ShutingyardType;
 })(ShutingyardType = exports.ShutingyardType || (exports.ShutingyardType = {}));
 var ShutingyardMode;
 (function (ShutingyardMode) {
+    ShutingyardMode["EXPRESSION"] = "expression";
     ShutingyardMode["POLYNOM"] = "polynom";
     ShutingyardMode["SET"] = "set";
     ShutingyardMode["NUMERIC"] = "numeric";
@@ -6846,6 +6865,9 @@ class Shutingyard {
         // console.log(this._rpn)
         return this._rpn;
     }
+    get rpnToken() {
+        return this._rpn.map(x => x.token);
+    }
     /**
      * Determin if the token is a defined operation
      * Defined operations: + - * / ^ sin cos tan
@@ -6887,6 +6909,22 @@ class Shutingyard {
             };
             this._uniformize = false;
         }
+        else if (this._mode === ShutingyardMode.EXPRESSION) {
+            this._tokenConfig = {
+                '^': { precedence: 4, associative: 'right', type: ShutingyardType.OPERATION },
+                '*': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
+                '/': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
+                '+': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION },
+                '-': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION },
+                '%': { precedence: 3, associative: 'right', type: ShutingyardType.OPERATION },
+                'sin': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+                'cos': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+                'tan': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+                'sqrt': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+                'nthrt': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+            };
+            this._uniformize = true;
+        }
         else {
             this._tokenConfig = {
                 '^': { precedence: 4, associative: 'right', type: ShutingyardType.OPERATION },
@@ -6894,10 +6932,6 @@ class Shutingyard {
                 '/': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
                 '+': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION },
                 '-': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION },
-                // '%': {precedence: 3, associative: 'right', type: ShutingyardType.OPERATION},
-                // 'sin': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
-                // 'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
-                // 'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
             };
             this._uniformize = true;
         }
@@ -6929,9 +6963,6 @@ class Shutingyard {
             tokenType = 'function-argument';
         }
         else {
-            // Order token keys by token characters length (descending)
-            // TODO: this is done each time ! SHould be done once !
-            // const keys = Object.keys(this._tokenConfig).sort((a,b)=>b.length-a.length)
             // Extract operation and function tokens
             for (let key of this._tokenKeys) {
                 if (expr.substring(start, start + key.length) === key) {
@@ -6953,7 +6984,7 @@ class Shutingyard {
                 if (expr[start].match(/[0-9]/)) {
                     if (this._mode === ShutingyardMode.POLYNOM && false) {}
                     else {
-                        token = expr.substring(start).match(/^([0-9.,]+)/)[0];
+                        token = expr.substring(start).match(/^([0-9.]+)/)[0];
                     }
                     tokenType = ShutingyardType.COEFFICIENT;
                 }
@@ -6970,19 +7001,114 @@ class Shutingyard {
         }
         return [token, start + token.length, tokenType];
     }
+    normalize(expr) {
+        // Get the list of function token.
+        let fnToken = [], kToken = [];
+        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);
+        for (let token in exports.tokenConstant) {
+            kToken.push(token);
+        }
+        // sort if from the lengthy to the smallest function
+        kToken.sort((a, b) => b.length - a.length);
+        let normalizedExpr = "", i = 0, crtToken, nextToken;
+        while (i < expr.length - 1) {
+            // Check if we have a function token.
+            // The function MUST have an open parentheses
+            let tokenIdx = 0;
+            while (tokenIdx < fnToken.length) {
+                let token = fnToken[tokenIdx];
+                if (expr.slice(i, i + token.length + 1) === token + '(') {
+                    normalizedExpr += token + '(';
+                    i += token.length + 1;
+                    // Restart the scan for the function token
+                    tokenIdx = 0;
+                }
+                else {
+                    // scan for a next function token
+                    tokenIdx++;
+                }
+            }
+            // Check for a constant
+            tokenIdx = 0;
+            while (tokenIdx < kToken.length) {
+                let token = kToken[tokenIdx];
+                if (expr.slice(i, i + token.length) === token) {
+                    // We have found a constant.
+                    // add it, but with remove the last letter
+                    normalizedExpr += token.slice(0, -1);
+                    i += token.length - 1;
+                    // Exit the loop
+                    break;
+                }
+                tokenIdx++;
+            }
+            // The function token are solved.
+            crtToken = expr[i];
+            nextToken = expr[i + 1];
+            normalizedExpr += crtToken;
+            if (crtToken.match(/[a-zA-Z]/g)) {
+                // Current element is a letter.
+                // if the next element is a letter, a number or an opening parentheses, add the multiplication sign.
+                if (nextToken.match(/[a-zA-Z\d(]/)) {
+                    normalizedExpr += '*';
+                }
+            }
+            else if (crtToken.match(/\d/)) {
+                // Current element is a number.
+                // if the next element is a letter or a parentheses, add the multiplication sign.
+                if (nextToken.match(/[a-zA-Z(]/)) {
+                    normalizedExpr += '*';
+                }
+            }
+            else if (crtToken === ')') {
+                // Current element is a closing parentheses.
+                // if the next element is a letter, a number or an opening parentheses, add the multiplication sign
+                if (nextToken.match(/[a-zA-Z\d(]/)) {
+                    normalizedExpr += '*';
+                }
+            }
+            // Go to next token
+            i++;
+        }
+        // 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 = expr.replace(/\)\(/g, ')*(');
+        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");
@@ -6992,14 +7118,24 @@ class Shutingyard {
         // 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 ?
-        // TODO: More robust solution to handle all letters ?
-        expr2 = expr2.replace(/([abcxyz])([abcxyz])/g, "$1*$2");
-        // Restore operation auto formating (prevent adding the mutliplcation star)
-        // TODO: Accept list of functions
-        let fnToken = ['sin', 'cos', 'tan'];
-        for (let token of fnToken) {
-            expr2 = expr2.replace(new RegExp(token + '\\*', 'g'), token);
+        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;
     }
@@ -7013,7 +7149,9 @@ class Shutingyard {
         let outQueue = [], // Output queue
         opStack = [], // Operation queue
         token = '', tokenPos = 0, tokenType = '', previousOpStatckLength = 0;
-        expr = this.Uniformizer(expr);
+        // Normalize the input if required.
+        if (this._uniformize)
+            expr = this.normalize(expr);
         let securityLoopLvl1 = 50, securityLoopLvl2_default = 50, securityLoopLvl2;
         while (tokenPos < expr.length) {
             securityLoopLvl1--;
@@ -7032,10 +7170,6 @@ class Shutingyard {
                         token,
                         tokenType
                     });
-                    // if(previousOpStatckLength == opStack.length && outQueue.length>=2){
-                    //     console.log('opStatckLength', outQueue, opStack.length)
-                    //     outQueue.push('*')
-                    // }
                     break;
                 case 'operation':
                     previousOpStatckLength = opStack.length;