pimath 0.0.120 → 0.0.122

package/esm/maths/shutingyard.js

@@ -1,443 +1,443 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Shutingyard = exports.ShutingyardMode = exports.ShutingyardType = exports.tokenConstant = void 0;
-exports.tokenConstant = {
-    pi: Math.PI,
-    e: Math.exp(1)
-};
-var ShutingyardType;
-(function (ShutingyardType) {
-    ShutingyardType["VARIABLE"] = "variable";
-    ShutingyardType["COEFFICIENT"] = "coefficient";
-    ShutingyardType["OPERATION"] = "operation";
-    ShutingyardType["CONSTANT"] = "constant";
-    ShutingyardType["FUNCTION"] = "function";
-    ShutingyardType["MONOM"] = "monom";
-})(ShutingyardType = exports.ShutingyardType || (exports.ShutingyardType = {}));
-var ShutingyardMode;
-(function (ShutingyardMode) {
-    ShutingyardMode["EXPRESSION"] = "expression";
-    ShutingyardMode["POLYNOM"] = "polynom";
-    ShutingyardMode["SET"] = "set";
-    ShutingyardMode["NUMERIC"] = "numeric";
-})(ShutingyardMode = exports.ShutingyardMode || (exports.ShutingyardMode = {}));
-class Shutingyard {
-    constructor(mode) {
-        this._rpn = [];
-        this._mode = typeof mode === 'undefined' ? ShutingyardMode.POLYNOM : mode;
-        this.tokenConfigInitialization();
-    }
-    // Getter
-    get rpn() {
-        // 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
-     * @param token
-     */
-    // isOperation(token: string): boolean {
-    //     if (token[0].match(/[+\-*/^]/g)) {
-    //         return true;
-    //     }
-    //     //
-    //     // if (token.match(/^sin|cos|tan/g)) {
-    //     //     return true;
-    //     // }
-    //
-    //     return false;
-    // }
-    tokenConfigInitialization() {
-        if (this._mode === ShutingyardMode.SET) {
-            this._tokenConfig = {
-                '&': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
-                '|': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
-                '!': { precedence: 4, associative: 'right', type: ShutingyardType.OPERATION },
-                '-': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION }
-            };
-            this._uniformize = false;
-        }
-        else if (this._mode === ShutingyardMode.NUMERIC) {
-            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 },
-                'ln': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
-                'log': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
-            };
-            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 },
-                '*': { 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 },
-            };
-            this._uniformize = true;
-        }
-        this._tokenKeys = Object.keys(this._tokenConfig).sort((a, b) => b.length - a.length);
-        return this._tokenConfig;
-    }
-    /**
-     * Get the next token to analyse.
-     * @param expr (string) Expression to analyse
-     * @param start (number) CUrrent position in the expr string.
-     */
-    NextToken(expr, start) {
-        let token, tokenType;
-        token = '';
-        tokenType = '';
-        // Case of parenthesis or comma (generic items)
-        if (expr[start] === '(') {
-            token = '(';
-            tokenType = '(';
-        }
-        // It's a closing parenthese
-        else if (expr[start] === ')') {
-            token = ')';
-            tokenType = ')';
-        }
-        // It's an argument separator for a function
-        else if (expr[start] === ',') {
-            token = ',';
-            tokenType = 'function-argument';
-        }
-        else {
-            // Extract operation and function tokens
-            for (let key of this._tokenKeys) {
-                if (expr.substring(start, start + key.length) === key) {
-                    token += key;
-                    tokenType = this._tokenConfig[key].type;
-                    break;
-                }
-            }
-            // Extract constant
-            for (let key in exports.tokenConstant) {
-                if (expr.substring(start, start + key.length) === key) {
-                    token += key;
-                    tokenType = ShutingyardType.CONSTANT;
-                    break;
-                }
-            }
-            if (token === '') {
-                // No function found ! Might be a coefficient !
-                if (expr[start].match(/[0-9]/)) {
-                    if (this._mode === ShutingyardMode.POLYNOM && false) {
-                        token = expr.substring(start).match(/^([0-9.,/]+)/)[0];
-                    }
-                    else {
-                        token = expr.substring(start).match(/^([0-9.]+)/)[0];
-                    }
-                    tokenType = ShutingyardType.COEFFICIENT;
-                }
-                else if (expr[start].match(/[a-zA-Z]/)) {
-                    token = expr.substring(start).match(/^([a-zA-Z])/)[0];
-                    tokenType = ShutingyardType.VARIABLE;
-                }
-                else {
-                    console.log('Unidentified token', expr[start], expr, start);
-                    token = expr[start];
-                    tokenType = ShutingyardType.MONOM;
-                }
-            }
-        }
-        return [token, start + token.length, tokenType];
-    }
-    normalize(expr) {
-        if (expr.length === 1) {
-            return 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: 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 uniformize
-     */
-    parse(expr, uniformize) {
-        let outQueue = [], // Output queue
-        opStack = [], // Operation queue
-        token = '', tokenPos = 0, tokenType = '', previousOpStatckLength = 0;
-        // Normalize the input if required.
-        if (uniformize || this._uniformize)
-            expr = this.normalize(expr);
-        let securityLoopLvl1 = 50, securityLoopLvl2_default = 50, securityLoopLvl2;
-        while (tokenPos < expr.length) {
-            securityLoopLvl1--;
-            if (securityLoopLvl1 === 0) {
-                console.log('SECURITY LEVEL 1 EXIT');
-                break;
-            }
-            // Get the next token and the corresponding new (ending) position
-            [token, tokenPos, tokenType] = this.NextToken(expr, tokenPos);
-            switch (tokenType) {
-                case 'monom':
-                case 'coefficient':
-                case 'variable':
-                case 'constant':
-                    outQueue.push({
-                        token,
-                        tokenType
-                    });
-                    break;
-                case 'operation':
-                    previousOpStatckLength = opStack.length;
-                    //If the token is an operator, o1, then:
-                    if (opStack.length > 0) {
-                        let opTop = opStack[opStack.length - 1];
-                        securityLoopLvl2 = +securityLoopLvl2_default;
-                        //while there is an operator token o2, at the top of the operator stack and
-                        while (opTop.token in this._tokenConfig && (
-                        //either o1 is left-associative and its precedence is less than or equal to that of o2,
-                        (this._tokenConfig[token].associative === 'left' && this._tokenConfig[token].precedence <= this._tokenConfig[opTop.token].precedence)
-                            ||
-                                //or o1 is right associative, and has precedence less than that of o2,
-                                (this._tokenConfig[token].associative === 'right' && this._tokenConfig[token].precedence < this._tokenConfig[opTop.token].precedence))) {
-                            /* Security exit ! */
-                            securityLoopLvl2--;
-                            if (securityLoopLvl2 === 0) {
-                                console.log('SECURITY LEVEL 2 OPERATION EXIT');
-                                break;
-                            }
-                            // Add the operation to the queue
-                            outQueue.push((opStack.pop()) || { token: '', tokenType: 'operation' });
-                            // Get the next operation on top of the Stack.
-                            if (opStack.length === 0) {
-                                break;
-                            }
-                            opTop = opStack[opStack.length - 1];
-                        }
-                    }
-                    //at the end of iteration push o1 onto the operator stack
-                    opStack.push({ token, tokenType });
-                    break;
-                case 'function-argument':
-                    // TODO: check if the opStack exist.
-                    securityLoopLvl2 = +securityLoopLvl2_default;
-                    while (opStack[opStack.length - 1].token !== '(' && opStack.length > 0) {
-                        securityLoopLvl2--;
-                        if (securityLoopLvl2 === 0) {
-                            console.log('SECURITY LEVEL 2 FUNCTION ARGUMENT EXIT');
-                            break;
-                        }
-                        outQueue.push((opStack.pop()) || { token, tokenType });
-                    }
-                    break;
-                case '(':
-                    opStack.push({ token, tokenType });
-                    // Add an empty value if next element is negative.
-                    if (expr[tokenPos] === '-') {
-                        outQueue.push({ token: '0', tokenType: 'coefficient' });
-                    }
-                    break;
-                case ')':
-                    securityLoopLvl2 = +securityLoopLvl2_default;
-                    //Until the token at the top of the stack is a left parenthesis, pop operators off the stack onto the output queue.
-                    while (opStack[opStack.length - 1].token !== '(' && opStack.length > 1 /*Maybe zero !? */) {
-                        securityLoopLvl2--;
-                        if (securityLoopLvl2 === 0) {
-                            console.log('SECURITY LEVEL 2 CLOSING PARENTHESE EXIT');
-                            break;
-                        }
-                        outQueue.push((opStack.pop()) || { token, tokenType });
-                    }
-                    //Pop the left parenthesis from the stack, but not onto the output queue.
-                    opStack.pop();
-                    break;
-                case 'function':
-                    opStack.push({ token, tokenType });
-                    break;
-                default:
-                    // In theory, everything should be handled.
-                    console.log(`SHUTING YARD: ${tokenType} : ${token} `);
-            }
-            // Output
-            // console.log(outQueue.concat(opStack.reverse()).join(" "));
-        }
-        // console.log(outQueue.concat(opStack.reverse()));
-        this._rpn = outQueue.concat(opStack.reverse());
-        return this;
-    }
-}
-exports.Shutingyard = Shutingyard;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shutingyard = exports.ShutingyardMode = exports.ShutingyardType = exports.tokenConstant = void 0;
+exports.tokenConstant = {
+    pi: Math.PI,
+    e: Math.exp(1)
+};
+var ShutingyardType;
+(function (ShutingyardType) {
+    ShutingyardType["VARIABLE"] = "variable";
+    ShutingyardType["COEFFICIENT"] = "coefficient";
+    ShutingyardType["OPERATION"] = "operation";
+    ShutingyardType["CONSTANT"] = "constant";
+    ShutingyardType["FUNCTION"] = "function";
+    ShutingyardType["MONOM"] = "monom";
+})(ShutingyardType || (exports.ShutingyardType = ShutingyardType = {}));
+var ShutingyardMode;
+(function (ShutingyardMode) {
+    ShutingyardMode["EXPRESSION"] = "expression";
+    ShutingyardMode["POLYNOM"] = "polynom";
+    ShutingyardMode["SET"] = "set";
+    ShutingyardMode["NUMERIC"] = "numeric";
+})(ShutingyardMode || (exports.ShutingyardMode = ShutingyardMode = {}));
+class Shutingyard {
+    constructor(mode) {
+        this._rpn = [];
+        this._mode = typeof mode === 'undefined' ? ShutingyardMode.POLYNOM : mode;
+        this.tokenConfigInitialization();
+    }
+    // Getter
+    get rpn() {
+        // 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
+     * @param token
+     */
+    // isOperation(token: string): boolean {
+    //     if (token[0].match(/[+\-*/^]/g)) {
+    //         return true;
+    //     }
+    //     //
+    //     // if (token.match(/^sin|cos|tan/g)) {
+    //     //     return true;
+    //     // }
+    //
+    //     return false;
+    // }
+    tokenConfigInitialization() {
+        if (this._mode === ShutingyardMode.SET) {
+            this._tokenConfig = {
+                '&': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
+                '|': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
+                '!': { precedence: 4, associative: 'right', type: ShutingyardType.OPERATION },
+                '-': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION }
+            };
+            this._uniformize = false;
+        }
+        else if (this._mode === ShutingyardMode.NUMERIC) {
+            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 },
+                'ln': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+                'log': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+            };
+            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 },
+                '*': { 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 },
+            };
+            this._uniformize = true;
+        }
+        this._tokenKeys = Object.keys(this._tokenConfig).sort((a, b) => b.length - a.length);
+        return this._tokenConfig;
+    }
+    /**
+     * Get the next token to analyse.
+     * @param expr (string) Expression to analyse
+     * @param start (number) CUrrent position in the expr string.
+     */
+    NextToken(expr, start) {
+        let token, tokenType;
+        token = '';
+        tokenType = '';
+        // Case of parenthesis or comma (generic items)
+        if (expr[start] === '(') {
+            token = '(';
+            tokenType = '(';
+        }
+        // It's a closing parenthese
+        else if (expr[start] === ')') {
+            token = ')';
+            tokenType = ')';
+        }
+        // It's an argument separator for a function
+        else if (expr[start] === ',') {
+            token = ',';
+            tokenType = 'function-argument';
+        }
+        else {
+            // Extract operation and function tokens
+            for (let key of this._tokenKeys) {
+                if (expr.substring(start, start + key.length) === key) {
+                    token += key;
+                    tokenType = this._tokenConfig[key].type;
+                    break;
+                }
+            }
+            // Extract constant
+            for (let key in exports.tokenConstant) {
+                if (expr.substring(start, start + key.length) === key) {
+                    token += key;
+                    tokenType = ShutingyardType.CONSTANT;
+                    break;
+                }
+            }
+            if (token === '') {
+                // No function found ! Might be a coefficient !
+                if (expr[start].match(/[0-9]/)) {
+                    if (this._mode === ShutingyardMode.POLYNOM && false) {
+                        token = expr.substring(start).match(/^([0-9.,/]+)/)[0];
+                    }
+                    else {
+                        token = expr.substring(start).match(/^([0-9.]+)/)[0];
+                    }
+                    tokenType = ShutingyardType.COEFFICIENT;
+                }
+                else if (expr[start].match(/[a-zA-Z]/)) {
+                    token = expr.substring(start).match(/^([a-zA-Z])/)[0];
+                    tokenType = ShutingyardType.VARIABLE;
+                }
+                else {
+                    console.log('Unidentified token', expr[start], expr, start);
+                    token = expr[start];
+                    tokenType = ShutingyardType.MONOM;
+                }
+            }
+        }
+        return [token, start + token.length, tokenType];
+    }
+    normalize(expr) {
+        if (expr.length === 1) {
+            return 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: 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 uniformize
+     */
+    parse(expr, uniformize) {
+        let outQueue = [], // Output queue
+        opStack = [], // Operation queue
+        token = '', tokenPos = 0, tokenType = '', previousOpStatckLength = 0;
+        // Normalize the input if required.
+        if (uniformize || this._uniformize)
+            expr = this.normalize(expr);
+        let securityLoopLvl1 = 50, securityLoopLvl2_default = 50, securityLoopLvl2;
+        while (tokenPos < expr.length) {
+            securityLoopLvl1--;
+            if (securityLoopLvl1 === 0) {
+                console.log('SECURITY LEVEL 1 EXIT');
+                break;
+            }
+            // Get the next token and the corresponding new (ending) position
+            [token, tokenPos, tokenType] = this.NextToken(expr, tokenPos);
+            switch (tokenType) {
+                case 'monom':
+                case 'coefficient':
+                case 'variable':
+                case 'constant':
+                    outQueue.push({
+                        token,
+                        tokenType
+                    });
+                    break;
+                case 'operation':
+                    previousOpStatckLength = opStack.length;
+                    //If the token is an operator, o1, then:
+                    if (opStack.length > 0) {
+                        let opTop = opStack[opStack.length - 1];
+                        securityLoopLvl2 = +securityLoopLvl2_default;
+                        //while there is an operator token o2, at the top of the operator stack and
+                        while (opTop.token in this._tokenConfig && (
+                        //either o1 is left-associative and its precedence is less than or equal to that of o2,
+                        (this._tokenConfig[token].associative === 'left' && this._tokenConfig[token].precedence <= this._tokenConfig[opTop.token].precedence)
+                            ||
+                                //or o1 is right associative, and has precedence less than that of o2,
+                                (this._tokenConfig[token].associative === 'right' && this._tokenConfig[token].precedence < this._tokenConfig[opTop.token].precedence))) {
+                            /* Security exit ! */
+                            securityLoopLvl2--;
+                            if (securityLoopLvl2 === 0) {
+                                console.log('SECURITY LEVEL 2 OPERATION EXIT');
+                                break;
+                            }
+                            // Add the operation to the queue
+                            outQueue.push((opStack.pop()) || { token: '', tokenType: 'operation' });
+                            // Get the next operation on top of the Stack.
+                            if (opStack.length === 0) {
+                                break;
+                            }
+                            opTop = opStack[opStack.length - 1];
+                        }
+                    }
+                    //at the end of iteration push o1 onto the operator stack
+                    opStack.push({ token, tokenType });
+                    break;
+                case 'function-argument':
+                    // TODO: check if the opStack exist.
+                    securityLoopLvl2 = +securityLoopLvl2_default;
+                    while (opStack[opStack.length - 1].token !== '(' && opStack.length > 0) {
+                        securityLoopLvl2--;
+                        if (securityLoopLvl2 === 0) {
+                            console.log('SECURITY LEVEL 2 FUNCTION ARGUMENT EXIT');
+                            break;
+                        }
+                        outQueue.push((opStack.pop()) || { token, tokenType });
+                    }
+                    break;
+                case '(':
+                    opStack.push({ token, tokenType });
+                    // Add an empty value if next element is negative.
+                    if (expr[tokenPos] === '-') {
+                        outQueue.push({ token: '0', tokenType: 'coefficient' });
+                    }
+                    break;
+                case ')':
+                    securityLoopLvl2 = +securityLoopLvl2_default;
+                    //Until the token at the top of the stack is a left parenthesis, pop operators off the stack onto the output queue.
+                    while (opStack[opStack.length - 1].token !== '(' && opStack.length > 1 /*Maybe zero !? */) {
+                        securityLoopLvl2--;
+                        if (securityLoopLvl2 === 0) {
+                            console.log('SECURITY LEVEL 2 CLOSING PARENTHESE EXIT');
+                            break;
+                        }
+                        outQueue.push((opStack.pop()) || { token, tokenType });
+                    }
+                    //Pop the left parenthesis from the stack, but not onto the output queue.
+                    opStack.pop();
+                    break;
+                case 'function':
+                    opStack.push({ token, tokenType });
+                    break;
+                default:
+                    // In theory, everything should be handled.
+                    console.log(`SHUTING YARD: ${tokenType} : ${token} `);
+            }
+            // Output
+            // console.log(outQueue.concat(opStack.reverse()).join(" "));
+        }
+        // console.log(outQueue.concat(opStack.reverse()));
+        this._rpn = outQueue.concat(opStack.reverse());
+        return this;
+    }
+}
+exports.Shutingyard = Shutingyard;
 //# sourceMappingURL=shutingyard.js.map