pimath 0.0.30 → 0.0.31

package/dev/pi.js

@@ -127,7 +127,7 @@ class Equation {
         let pStr, strSign;
         strSign = this._findSign(equationString);
         if (strSign === false) {
-            console.log('The equation is not valid (no sign found)');
+            console.error('The equation is not valid (no sign found)');
             return;
         }
         pStr = equationString.split(strSign);
@@ -634,6 +634,7 @@ __exportStar(__webpack_require__(/*! ./logicalset */ "./src/maths/algebra/logica
 __exportStar(__webpack_require__(/*! ./monom */ "./src/maths/algebra/monom.ts"), exports);
 __exportStar(__webpack_require__(/*! ./polynom */ "./src/maths/algebra/polynom.ts"), exports);
 __exportStar(__webpack_require__(/*! ./rational */ "./src/maths/algebra/rational.ts"), exports);
+__exportStar(__webpack_require__(/*! ./../expressions/polynomexp */ "./src/maths/expressions/polynomexp.ts"), exports);
 
 
 /***/ }),
@@ -1071,8 +1072,8 @@ class Monom {
         }
     }
     get variables() {
-        this.clone().clean();
-        return Object.keys(this._literal);
+        let M = this.clone().clean();
+        return Object.keys(M.literal);
     }
     get display() {
         let L = '', letters = Object.keys(this._literal).sort();
@@ -1187,7 +1188,7 @@ class Monom {
             if (this._literal[letter].isNotZero()) {
                 L += `${letter}`;
                 if (this._literal[letter].isNotEqual(1)) {
-                    L += `^{${this._literal[letter].display}}`;
+                    L += `^{${this._literal[letter].tfrac}}`;
                 }
             }
         }
@@ -1232,6 +1233,45 @@ class Monom {
         }
         return this;
     };
+    static addToken = (stack, element) => {
+        let q1, q2, m, letter, pow;
+        if (element.tokenType === shutingyard_1.ShutingyardType.COEFFICIENT) {
+            stack.push(new Monom(new coefficients_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 '-':
+                    q2 = (stack.pop()) || new Monom().zero();
+                    q1 = (stack.pop()) || new Monom().zero();
+                    stack.push(q1.subtract(q2));
+                    break;
+                case '*':
+                    q2 = (stack.pop()) || new Monom().one();
+                    q1 = (stack.pop()) || new Monom().one();
+                    stack.push(q1.multiply(q2));
+                    break;
+                case '/':
+                    q2 = (stack.pop()) || new Monom().one();
+                    q1 = (stack.pop()) || new Monom().one();
+                    stack.push(q1.divide(q2));
+                    break;
+                case '^':
+                    pow = (stack.pop().coefficient) || new coefficients_1.Fraction().one();
+                    m = (stack.pop()) || new Monom().one();
+                    letter = m.variables[0];
+                    if (letter !== undefined) {
+                        m.setLetter(letter, pow);
+                    }
+                    stack.push(m);
+                    break;
+            }
+        }
+    };
     _shutingYardToReducedMonom = (inputStr) => {
         const SY = new shutingyard_1.Shutingyard().parse(inputStr);
         const rpn = SY.rpn;
@@ -1253,39 +1293,7 @@ class Monom {
         }
         else {
             for (const element of rpn) {
-                if (element.tokenType === 'coefficient') {
-                    let M = new Monom().one();
-                    M.coefficient = new coefficients_1.Fraction(element.token);
-                    stack.push(M.clone());
-                }
-                else if (element.tokenType === 'variable') {
-                    let M = new Monom().one();
-                    M.setLetter(element.token, 1);
-                    stack.push(M.clone());
-                }
-                else if (element.tokenType === 'operation') {
-                    switch (element.token) {
-                        case '-':
-                            q2 = (stack.pop()) || new Monom().zero();
-                            q1 = (stack.pop()) || new Monom().zero();
-                            stack.push(q1.subtract(q2));
-                            break;
-                        case '*':
-                            q2 = (stack.pop()) || new Monom().one();
-                            q1 = (stack.pop()) || new Monom().one();
-                            stack.push(q1.multiply(q2));
-                            break;
-                        case '^':
-                            pow = (stack.pop().coefficient) || new coefficients_1.Fraction().one();
-                            m = (stack.pop()) || new Monom().one();
-                            letter = m.variables[0];
-                            if (letter !== undefined) {
-                                m.setLetter(letter, pow);
-                            }
-                            stack.push(m);
-                            break;
-                    }
-                }
+                Monom.addToken(stack, element);
             }
         }
         this.one();
@@ -1331,6 +1339,11 @@ class Monom {
         }
         return this;
     };
+    reduce = () => {
+        this.clean();
+        this.coefficient.reduce();
+        return this;
+    };
     opposed = () => {
         this._coefficient.opposed();
         return this;
@@ -1396,7 +1409,7 @@ class Monom {
     pow = (nb) => {
         this._coefficient.pow(nb);
         for (let letter in this._literal) {
-            this._literal[letter].pow(nb);
+            this._literal[letter].multiply(nb);
         }
         return this;
     };
@@ -1424,6 +1437,9 @@ class Monom {
                 return this._coefficient.isEqual(M.coefficient);
             case 'same':
                 let M1 = this.variables, M2 = M.variables, K = M1.concat(M2.filter((item) => M1.indexOf(item) < 0));
+                if (M1.length === 0 && M2.length === 0) {
+                    return true;
+                }
                 if (!this.isZero() && !M.isZero()) {
                     for (let key of K) {
                         if (this._literal[key] === undefined || M.literal[key] === undefined) {
@@ -1627,9 +1643,6 @@ const numeric_1 = __webpack_require__(/*! ../numeric */ "./src/maths/numeric.ts"
 const coefficients_1 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
 class Polynom {
     _rawString;
-    _monoms;
-    _factors;
-    _texString;
     constructor(polynomString, ...values) {
         this._monoms = [];
         this._factors = [];
@@ -1638,18 +1651,24 @@ class Polynom {
         }
         return this;
     }
+    _monoms;
     get monoms() {
         return this._monoms;
     }
     set monoms(M) {
         this._monoms = M;
     }
+    _factors;
     get factors() {
         return this._factors;
     }
     set factors(value) {
         this._factors = value;
     }
+    _texString;
+    get texString() {
+        return this._texString;
+    }
     get texFactors() {
         this.factorize();
         let tex = '';
@@ -1663,9 +1682,6 @@ class Polynom {
         }
         return tex;
     }
-    get texString() {
-        return this._texString;
-    }
     get length() {
         return this._monoms.length;
     }
@@ -1698,28 +1714,23 @@ class Polynom {
     get numberOfVars() {
         return this.variables.length;
     }
-    genDisplay = (output, forceSign, wrapParentheses) => {
-        let P = '';
-        for (const k of this._monoms) {
-            if (k.coefficient.value === 0) {
-                continue;
-            }
-            P += `${(k.coefficient.sign() === 1 && (P !== '' || forceSign === true)) ? '+' : ''}${(output === 'tex') ? k.tex : k.display}`;
+    parse = (inputStr, ...values) => {
+        this._monoms = [];
+        this._factors = [];
+        if (typeof inputStr === 'string') {
+            return this._parseString(inputStr, ...values);
         }
-        if (wrapParentheses === true && this.length > 1) {
-            if (output === 'tex') {
-                P = `\\left( ${P} \\right)`;
-            }
-            else {
-                P = `(${P})`;
-            }
+        else if (typeof inputStr === 'number' || inputStr instanceof coefficients_1.Fraction || inputStr instanceof monom_1.Monom) {
+            this._monoms.push(new monom_1.Monom(inputStr));
         }
-        if (P === '') {
-            P = '0';
+        else if (inputStr instanceof Polynom) {
+            for (const m of inputStr.monoms) {
+                this._monoms.push(m.clone());
+            }
         }
-        return P;
+        return this;
     };
-    parse = (inputStr, ...values) => {
+    _parseString(inputStr, ...values) {
         if (values === undefined || values.length === 0) {
             inputStr = '' + inputStr;
             this._rawString = inputStr;
@@ -1759,41 +1770,7 @@ class Polynom {
         else {
             return this.zero();
         }
-    };
-    shutingYardToReducedPolynom = (inputStr) => {
-        const SY = new shutingyard_1.Shutingyard().parse(inputStr);
-        const rpn = SY.rpn;
-        let m1;
-        let m2;
-        let stack = [], previousToken = null, tempPolynom;
-        for (const element of rpn) {
-            if (element.tokenType === 'coefficient' || element.tokenType === 'variable') {
-                tempPolynom = new Polynom().zero();
-                tempPolynom.monoms = [new monom_1.Monom(element.token)];
-                stack.push(tempPolynom.clone());
-            }
-            else if (element.tokenType === 'operation') {
-                m2 = (stack.pop()) || new Polynom().zero();
-                m1 = (stack.pop()) || new Polynom().zero();
-                switch (element.token) {
-                    case '+':
-                        stack.push(m1.add(m2));
-                        break;
-                    case '-':
-                        stack.push(m1.subtract(m2));
-                        break;
-                    case '*':
-                        stack.push(m1.multiply(m2));
-                        break;
-                    case '^':
-                        stack.push(m1.pow(+previousToken));
-                }
-            }
-            previousToken = element.token;
-        }
-        this._monoms = stack[0].monoms;
-        return this;
-    };
+    }
     clone = () => {
         const P = new Polynom();
         const M = [];
@@ -1873,31 +1850,6 @@ class Polynom {
         }
         return this;
     };
-    multiplyByPolynom = (P) => {
-        const M = [];
-        for (const m1 of this._monoms) {
-            for (const m2 of P.monoms) {
-                M.push(monom_1.Monom.xmultiply(m1, m2));
-            }
-        }
-        this._monoms = M;
-        return this.reduce();
-    };
-    multiplyByFraction = (F) => {
-        for (const m of this._monoms) {
-            m.coefficient.multiply(F);
-        }
-        return this.reduce();
-    };
-    multiplyByInteger = (nb) => {
-        return this.multiplyByFraction(new coefficients_1.Fraction(nb));
-    };
-    multiplyByMonom = (M) => {
-        for (const m of this._monoms) {
-            m.multiply(M);
-        }
-        return this.reduce();
-    };
     euclidian = (P) => {
         const letter = P.variables[0];
         const quotient = new Polynom().zero();
@@ -1918,29 +1870,18 @@ class Polynom {
             quotient.add(newM);
             reminder.subtract(P.clone().multiply(newM));
         }
+        quotient.reduce();
+        reminder.reduce();
         return { quotient, reminder };
     };
     divide = (value) => {
         if (value instanceof coefficients_1.Fraction) {
-            this.divideByFraction(value);
+            return this.divideByFraction(value);
         }
         else if (typeof value === 'number' && Number.isSafeInteger(value)) {
             return this.divideByInteger(value);
         }
     };
-    divideByInteger = (nb) => {
-        const nbF = new coefficients_1.Fraction(nb);
-        for (const m of this._monoms) {
-            m.coefficient.divide(nbF);
-        }
-        return this;
-    };
-    divideByFraction = (F) => {
-        for (const m of this._monoms) {
-            m.coefficient.divide(F);
-        }
-        return this;
-    };
     pow = (nb) => {
         if (!Number.isSafeInteger(nb)) {
             return this.zero();
@@ -2197,82 +2138,6 @@ class Polynom {
         this.factors = factors;
         return factors;
     };
-    _factorize2ndDegree = (letter) => {
-        let P1, P2, a, b, c, delta, x1, x2, factor;
-        if (this.numberOfVars === 1) {
-            a = this.monomByDegree(2, letter).coefficient;
-            b = this.monomByDegree(1, letter).coefficient;
-            c = this.monomByDegree(0, letter).coefficient;
-            delta = b.clone().pow(2).subtract(a.clone().multiply(c).multiply(4));
-            if (delta.isZero()) {
-                x1 = b.clone().opposed().divide(a.clone().multiply(2));
-                P1 = new Polynom(letter).subtract(x1.display).multiply(x1.denominator);
-                P2 = new Polynom(letter).subtract(x1.display).multiply(x1.denominator);
-                factor = a.divide(x1.denominator).divide(x1.denominator);
-                if (!factor.isOne()) {
-                    return [new Polynom(factor.display), P1, P2];
-                }
-                else {
-                    return [P1, P2];
-                }
-            }
-            else if (delta.isPositive() && delta.isSquare()) {
-                x1 = b.clone().opposed()
-                    .add(delta.clone().sqrt())
-                    .divide(a.clone().multiply(2));
-                x2 = b.clone().opposed()
-                    .subtract(delta.clone().sqrt())
-                    .divide(a.clone().multiply(2));
-                factor = a.divide(x1.denominator).divide(x2.denominator);
-                if (factor.isOne()) {
-                    return [
-                        new Polynom(letter).subtract(x1.display).multiply(x1.denominator),
-                        new Polynom(letter).subtract(x2.display).multiply(x2.denominator),
-                    ];
-                }
-                else {
-                    return [
-                        new Polynom(factor.display),
-                        new Polynom(letter).subtract(x1.display).multiply(x1.denominator),
-                        new Polynom(letter).subtract(x2.display).multiply(x2.denominator),
-                    ];
-                }
-            }
-            else {
-                return [this.clone()];
-            }
-        }
-        else {
-            a = this.monomByDegree(2, letter);
-            b = this.monomByDegree(1, letter);
-            c = this.monomByDegree(0, letter);
-            if (a.isLiteralSquare() && c.isLiteralSquare()) {
-                if (b.clone().pow(2).isSameAs(a.clone().multiply(c))) {
-                    let xPolynom = new Polynom('x', a.coefficient, b.coefficient, c.coefficient);
-                    let xFactors = xPolynom._factorize2ndDegree('x');
-                    let factors = [], xyzPolynom;
-                    if (xFactors.length >= 2) {
-                        for (let p of xFactors) {
-                            if (p.degree().isZero()) {
-                                factors.push(p.clone());
-                            }
-                            else {
-                                xyzPolynom = p.clone();
-                                xyzPolynom.monoms[0].literal = a.literalSqrt;
-                                xyzPolynom.monoms[1].literal = c.literalSqrt;
-                                factors.push(xyzPolynom.clone());
-                            }
-                        }
-                        return factors;
-                    }
-                }
-            }
-            return [this.clone()];
-        }
-    };
-    _factorizeByGroups = () => {
-        return [];
-    };
     getZeroes = () => {
         const Z = [];
         switch (this.degree().value) {
@@ -2404,64 +2269,283 @@ class Polynom {
         }
         return M;
     };
-}
-exports.Polynom = Polynom;
-
-
-/***/ }),
-
-/***/ "./src/maths/algebra/rational.ts":
-/*!***************************************!*\
-  !*** ./src/maths/algebra/rational.ts ***!
-  \***************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Rational = void 0;
-const polynom_1 = __webpack_require__(/*! ./polynom */ "./src/maths/algebra/polynom.ts");
-const coefficients_1 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
-class Rational {
-    _rawString;
-    _numerator;
-    _denominator;
-    constructor(numerator, denominator) {
-        this._numerator = numerator ? numerator.clone() : new polynom_1.Polynom();
-        this._denominator = denominator ? denominator.clone() : new polynom_1.Polynom();
-    }
-    clone = () => {
-        this._numerator = this._numerator.clone();
-        this._denominator = this._denominator.clone();
-        return this;
-    };
-    get tex() {
-        return `\\dfrac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
-    }
-    get texFactors() {
-        this._numerator.factorize();
-        this._denominator.factorize();
-        return `\\dfrac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`;
-    }
-    get numerator() {
-        return this._numerator;
-    }
-    get denominator() {
-        return this._denominator;
-    }
-    domain = () => {
-        let zeroes = this._denominator.getZeroes();
-        if (zeroes.length === 0 || zeroes[0] === false) {
-            return '\\mathbb{R}';
-        }
-        else if (zeroes[0] === true) {
-            return '\\varnothing';
+    genDisplay = (output, forceSign, wrapParentheses) => {
+        let P = '';
+        for (const k of this._monoms) {
+            if (k.coefficient.value === 0) {
+                continue;
+            }
+            P += `${(k.coefficient.sign() === 1 && (P !== '' || forceSign === true)) ? '+' : ''}${(output === 'tex') ? k.tex : k.display}`;
         }
-        else {
-            return '\\mathbb{R}\\setminus\\left{' +
-                zeroes.map(x => {
-                    return (typeof x === 'boolean') ? '' : x.frac;
-                })
-                    .join(';') + '\\right}';
+        if (wrapParentheses === true && this.length > 1) {
+            if (output === 'tex') {
+                P = `\\left( ${P} \\right)`;
+            }
+            else {
+                P = `(${P})`;
+            }
+        }
+        if (P === '') {
+            P = '0';
+        }
+        return P;
+    };
+    static 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:
+                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()) {
+                                stack.push(a.pow(b.monoms[0].coefficient.value));
+                            }
+                            else {
+                                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:
+                console.error('The monom token should not appear here');
+                break;
+            case shutingyard_1.ShutingyardType.FUNCTION:
+                console.log('The function token should not appear here - might be introduced later.');
+                break;
+        }
+    };
+    shutingYardToReducedPolynom = (inputStr) => {
+        const SY = new shutingyard_1.Shutingyard().parse(inputStr);
+        const rpn = SY.rpn;
+        this.zero();
+        let stack = [], monom = new monom_1.Monom();
+        for (const element of rpn) {
+            Polynom.addToken(stack, element);
+        }
+        if (stack.length === 1) {
+            this.add(stack[0]);
+        }
+        return this;
+    };
+    multiplyByPolynom = (P) => {
+        const M = [];
+        for (const m1 of this._monoms) {
+            for (const m2 of P.monoms) {
+                M.push(monom_1.Monom.xmultiply(m1, m2));
+            }
+        }
+        this._monoms = M;
+        return this.reduce();
+    };
+    multiplyByFraction = (F) => {
+        for (const m of this._monoms) {
+            m.coefficient.multiply(F);
+        }
+        return this.reduce();
+    };
+    multiplyByInteger = (nb) => {
+        return this.multiplyByFraction(new coefficients_1.Fraction(nb));
+    };
+    multiplyByMonom = (M) => {
+        for (const m of this._monoms) {
+            m.multiply(M);
+        }
+        return this.reduce();
+    };
+    divideByInteger = (nb) => {
+        const nbF = new coefficients_1.Fraction(nb);
+        for (const m of this._monoms) {
+            m.coefficient.divide(nbF);
+        }
+        return this;
+    };
+    divideByFraction = (F) => {
+        for (const m of this._monoms) {
+            m.coefficient.divide(F);
+        }
+        return this;
+    };
+    _factorize2ndDegree = (letter) => {
+        let P1, P2, a, b, c, delta, x1, x2, factor;
+        if (this.numberOfVars === 1) {
+            a = this.monomByDegree(2, letter).coefficient;
+            b = this.monomByDegree(1, letter).coefficient;
+            c = this.monomByDegree(0, letter).coefficient;
+            delta = b.clone().pow(2).subtract(a.clone().multiply(c).multiply(4));
+            if (delta.isZero()) {
+                x1 = b.clone().opposed().divide(a.clone().multiply(2));
+                P1 = new Polynom(letter).subtract(x1.display).multiply(x1.denominator);
+                P2 = new Polynom(letter).subtract(x1.display).multiply(x1.denominator);
+                factor = a.divide(x1.denominator).divide(x1.denominator);
+                if (!factor.isOne()) {
+                    return [new Polynom(factor.display), P1, P2];
+                }
+                else {
+                    return [P1, P2];
+                }
+            }
+            else if (delta.isPositive() && delta.isSquare()) {
+                x1 = b.clone().opposed()
+                    .add(delta.clone().sqrt())
+                    .divide(a.clone().multiply(2));
+                x2 = b.clone().opposed()
+                    .subtract(delta.clone().sqrt())
+                    .divide(a.clone().multiply(2));
+                factor = a.divide(x1.denominator).divide(x2.denominator);
+                if (factor.isOne()) {
+                    return [
+                        new Polynom(letter).subtract(x1.display).multiply(x1.denominator),
+                        new Polynom(letter).subtract(x2.display).multiply(x2.denominator),
+                    ];
+                }
+                else {
+                    return [
+                        new Polynom(factor.display),
+                        new Polynom(letter).subtract(x1.display).multiply(x1.denominator),
+                        new Polynom(letter).subtract(x2.display).multiply(x2.denominator),
+                    ];
+                }
+            }
+            else {
+                return [this.clone()];
+            }
+        }
+        else {
+            a = this.monomByDegree(2, letter);
+            b = this.monomByDegree(1, letter);
+            c = this.monomByDegree(0, letter);
+            if (a.isLiteralSquare() && c.isLiteralSquare()) {
+                if (b.clone().pow(2).isSameAs(a.clone().multiply(c))) {
+                    let xPolynom = new Polynom('x', a.coefficient, b.coefficient, c.coefficient);
+                    let xFactors = xPolynom._factorize2ndDegree('x');
+                    let factors = [], xyzPolynom;
+                    if (xFactors.length >= 2) {
+                        for (let p of xFactors) {
+                            if (p.degree().isZero()) {
+                                factors.push(p.clone());
+                            }
+                            else {
+                                xyzPolynom = p.clone();
+                                xyzPolynom.monoms[0].literal = a.literalSqrt;
+                                xyzPolynom.monoms[1].literal = c.literalSqrt;
+                                factors.push(xyzPolynom.clone());
+                            }
+                        }
+                        return factors;
+                    }
+                }
+            }
+            return [this.clone()];
+        }
+    };
+    _factorizeByGroups = () => {
+        return [];
+    };
+}
+exports.Polynom = Polynom;
+
+
+/***/ }),
+
+/***/ "./src/maths/algebra/rational.ts":
+/*!***************************************!*\
+  !*** ./src/maths/algebra/rational.ts ***!
+  \***************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Rational = void 0;
+const polynom_1 = __webpack_require__(/*! ./polynom */ "./src/maths/algebra/polynom.ts");
+const coefficients_1 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
+class Rational {
+    _rawString;
+    _numerator;
+    _denominator;
+    constructor(numerator, denominator) {
+        this._numerator = numerator ? numerator.clone() : new polynom_1.Polynom();
+        this._denominator = denominator ? denominator.clone() : new polynom_1.Polynom();
+    }
+    clone = () => {
+        this._numerator = this._numerator.clone();
+        this._denominator = this._denominator.clone();
+        return this;
+    };
+    get tex() {
+        return `\\dfrac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
+    }
+    get texFactors() {
+        this._numerator.factorize();
+        this._denominator.factorize();
+        return `\\dfrac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`;
+    }
+    get numerator() {
+        return this._numerator;
+    }
+    get denominator() {
+        return this._denominator;
+    }
+    domain = () => {
+        let zeroes = this._denominator.getZeroes();
+        if (zeroes.length === 0 || zeroes[0] === false) {
+            return '\\mathbb{R}';
+        }
+        else if (zeroes[0] === true) {
+            return '\\varnothing';
+        }
+        else {
+            return '\\mathbb{R}\\setminus\\left{' +
+                zeroes.map(x => {
+                    return (typeof x === 'boolean') ? '' : x.frac;
+                })
+                    .join(';') + '\\right}';
         }
     };
     amplify = (P) => {
@@ -2592,6 +2676,9 @@ class Fraction {
     get dfrac() {
         return this.tex.replace('\\frac', '\\dfrac');
     }
+    get tfrac() {
+        return this.tex.replace('\\frac', '\\tfrac');
+    }
     parse = (value, denominatorOrPeriodic) => {
         let S;
         if (value === null || value === "") {
@@ -2644,6 +2731,7 @@ class Fraction {
                         this._numerator = value * Math.pow(10, p) - Math.floor(value * Math.pow(10, p - denominatorOrPeriodic));
                         this.denominator = Math.pow(10, p) - Math.pow(10, p - denominatorOrPeriodic);
                     }
+                    this.reduce();
                 }
                 break;
             case "object":
@@ -2730,15 +2818,21 @@ class Fraction {
         if (p instanceof Fraction) {
             return this.pow(p.value);
         }
-        if (!Number.isSafeInteger(p)) {
-            return this.invalid();
-        }
         this.reduce();
         if (p < 0) {
             this.invert();
         }
-        this._numerator = this._numerator ** Math.abs(p);
-        this._denominator = this._denominator ** Math.abs(p);
+        let controlNumerator = Math.floor(Math.pow(this._numerator, Math.abs(p))), controlDenominator = Math.floor(Math.pow(this._denominator, Math.abs(p)));
+        if (controlNumerator ** Math.abs(p) === this._numerator
+            &&
+                controlDenominator ** Math.abs(p) === this._denominator) {
+            this._numerator = this._numerator ** Math.abs(p);
+            this._denominator = this._denominator ** Math.abs(p);
+        }
+        else {
+            this._numerator = this._numerator ** Math.abs(p);
+            this._denominator = this._denominator ** Math.abs(p);
+        }
         return this;
     };
     root = (p) => {
@@ -2890,16 +2984,19 @@ class Fraction {
         return Math.abs(numeric_1.Numeric.gcd(this._numerator, this._denominator)) === 1;
     };
     isNatural = () => {
+        return this.isRelative() && this.isPositive();
+    };
+    isRelative = () => {
         return this.clone().reduce().denominator === 1;
     };
     isRational = () => {
-        return !this.isNatural();
+        return !this.isRelative();
     };
     isEven = () => {
-        return this.isNatural() && this.value % 2 === 0;
+        return this.isRelative() && this.value % 2 === 0;
     };
     isOdd = () => {
-        return this.isNatural() && this.value % 2 === 1;
+        return this.isRelative() && this.value % 2 === 1;
     };
     sign = () => {
         return (this._numerator * this._denominator >= 0) ? 1 : -1;
@@ -2950,102 +3047,500 @@ __exportStar(__webpack_require__(/*! ./nthroot */ "./src/maths/coefficients/nthr
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Nthroot = void 0;
-class Nthroot {
-    _radical;
-    _nth;
-    _coefficient;
-    _isValid;
-    constructor(...values) {
-        this._radical = 1;
-        this._coefficient = 1;
-        this._nth = 2;
-        this._isValid = true;
-        if (values !== undefined) {
-            this.parse(values[0], values[1], values[2]);
+exports.Nthroot = void 0;
+class Nthroot {
+    _radical;
+    _nth;
+    _coefficient;
+    _isValid;
+    constructor(...values) {
+        this._radical = 1;
+        this._coefficient = 1;
+        this._nth = 2;
+        this._isValid = true;
+        if (values !== undefined) {
+            this.parse(values[0], values[1], values[2]);
+        }
+    }
+    get radical() {
+        return this._radical;
+    }
+    set radical(value) {
+        this._radical = value;
+    }
+    get nth() {
+        return this._nth;
+    }
+    set nth(value) {
+        if (Number.isSafeInteger(value) && value >= 2) {
+            this._nth = value;
+        }
+        else {
+            console.log('Error setting the nth root');
+            this._nth = 2;
+        }
+    }
+    get coefficient() {
+        return this._coefficient;
+    }
+    set coefficient(value) {
+        this._coefficient = value;
+    }
+    get tex() {
+        let C;
+        if (this._coefficient === 1) {
+            C = '';
+        }
+        else if (this._coefficient === -1) {
+            C = '-';
+        }
+        else {
+            C = this._coefficient.toString();
+        }
+        if (this._radical === 1) {
+            return `${this._coefficient}`;
+        }
+        else {
+            if (this._nth === 2) {
+                return `${C}\\sqrt{${this._radical}}`;
+            }
+            else {
+                return `${C}\\sqrt[${this._nth}]{${this._radical}}`;
+            }
+        }
+    }
+    get value() {
+        return this._coefficient * Math.pow(this._radical, 1 / this._nth);
+    }
+    parse = (radical, nthroot, coefficient) => {
+        this._coefficient = (coefficient === undefined) ? 1 : coefficient;
+        this._nth = (nthroot === undefined) ? 2 : nthroot;
+        this._radical = (radical === undefined) ? 1 : radical;
+        if (this._nth % 2 === 0 && this._radical < 0) {
+            this._isValid = false;
+        }
+        return this;
+    };
+    reduce = () => {
+        let V = Math.floor(Math.pow(this._radical, 1 / this._nth));
+        while (V > 1) {
+            if (this._radical % Math.pow(V, this._nth) === 0) {
+                this._coefficient *= V;
+                this._radical = this._radical / Math.pow(V, this._nth);
+                V = Math.floor(Math.pow(this._radical, 1 / this._nth));
+                continue;
+            }
+            V--;
+        }
+        return this;
+    };
+    multiply = (N) => {
+        this._radical *= N.radical;
+        return this.reduce();
+    };
+    hasRadical = () => {
+        return !(this._radical === 1 || this._radical === 0 || this._isValid === false);
+    };
+}
+exports.Nthroot = Nthroot;
+
+
+/***/ }),
+
+/***/ "./src/maths/expressions/numexp.ts":
+/*!*****************************************!*\
+  !*** ./src/maths/expressions/numexp.ts ***!
+  \*****************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.NumExp = void 0;
+const shutingyard_1 = __webpack_require__(/*! ../shutingyard */ "./src/maths/shutingyard.ts");
+const coefficients_1 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
+class NumExp {
+    _rpn;
+    _expression;
+    _isValid;
+    constructor(value) {
+        this._expression = value;
+        this._rpn = new shutingyard_1.Shutingyard(shutingyard_1.ShutingyardMode.NUMERIC).parse(value).rpn;
+    }
+    get rpn() {
+        return this._rpn;
+    }
+    get isValid() {
+        if (this._isValid === undefined) {
+            this.evaluate({ x: 0 });
+        }
+        return this._isValid;
+    }
+    set isValid(value) {
+        this._isValid = value;
+    }
+    get expression() {
+        return this._expression;
+    }
+    _extractDecimalPart(value) {
+        let decimal = value.toString();
+        if (!decimal.includes('.')) {
+            return '';
+        }
+        decimal = decimal.split('.')[1];
+        return decimal.substring(0, decimal.length - 2);
+    }
+    _numberCorrection(value) {
+        const epsilon = 0.00000000000001, number_of_digits = 6;
+        const decimal = this._extractDecimalPart(value);
+        if (decimal === '') {
+            return value;
+        }
+        const n9 = decimal.match(/9+$/g);
+        const n0 = decimal.match(/0+$/g);
+        if (n9 && n9[0].length >= number_of_digits) {
+            const mod = this._extractDecimalPart(value + epsilon), mod0 = mod.match(/0+$/g);
+            if (mod0 && mod0[0].length >= number_of_digits) {
+                return +((value + epsilon).toString().split(mod0[0])[0]);
+            }
+        }
+        if (n0 && n0[0].length >= number_of_digits) {
+            const mod = this._extractDecimalPart(value - epsilon), mod9 = mod.match(/9+$/g);
+            if (mod9 && mod9[0].length >= number_of_digits) {
+                return +(value.toString().split(n0[0])[0]);
+            }
+        }
+        return value;
+    }
+    _addToStack(stack, value) {
+        stack.push(this._numberCorrection(value));
+    }
+    evaluate(values) {
+        const stack = [];
+        this.isValid = true;
+        for (const element of this._rpn) {
+            if (element.tokenType === shutingyard_1.ShutingyardType.COEFFICIENT) {
+                if (!isNaN(+element.token)) {
+                    this._addToStack(stack, +element.token);
+                }
+                else {
+                    this._addToStack(stack, new coefficients_1.Fraction(element.token).value);
+                }
+            }
+            else if (element.tokenType === shutingyard_1.ShutingyardType.VARIABLE) {
+                if (values[element.token] !== undefined) {
+                    this._addToStack(stack, +values[element.token]);
+                }
+            }
+            else if (element.tokenType === shutingyard_1.ShutingyardType.CONSTANT) {
+                this._addToStack(stack, shutingyard_1.tokenConstant[element.token]);
+            }
+            else if (element.tokenType === shutingyard_1.ShutingyardType.OPERATION) {
+                if (element.token === '*') {
+                    const b = stack.pop(), a = stack.pop();
+                    if (a === undefined || b === undefined) {
+                        this.isValid = false;
+                    }
+                    this._addToStack(stack, a * b);
+                }
+                else if (element.token === '/') {
+                    const b = stack.pop(), a = stack.pop();
+                    if (a === undefined || b === undefined) {
+                        this.isValid = false;
+                    }
+                    this._addToStack(stack, a / b);
+                }
+                else if (element.token === '+') {
+                    const b = stack.pop(), a = stack.pop();
+                    if (a === undefined || b === undefined) {
+                        this.isValid = false;
+                    }
+                    this._addToStack(stack, (+a) + (+b));
+                }
+                else if (element.token === '-') {
+                    const b = stack.pop(), a = stack.pop() || 0;
+                    if (b === undefined) {
+                        this.isValid = false;
+                    }
+                    this._addToStack(stack, a - b);
+                }
+                else if (element.token === '^') {
+                    const b = stack.pop(), a = stack.pop();
+                    if (a === undefined || b === undefined) {
+                        this.isValid = false;
+                    }
+                    this._addToStack(stack, Math.pow(a, b));
+                }
+            }
+            else if (element.tokenType === shutingyard_1.ShutingyardType.FUNCTION) {
+                const a = stack.pop();
+                if (a === undefined) {
+                    this.isValid = false;
+                }
+                if (element.token === 'sin') {
+                    this._addToStack(stack, Math.sin(a));
+                }
+                else if (element.token === 'cos') {
+                    this._addToStack(stack, Math.cos(a));
+                }
+                else if (element.token === 'tan') {
+                    this._addToStack(stack, Math.tan(a));
+                }
+                else if (element.token === 'sqrt') {
+                    this._addToStack(stack, Math.sqrt(a));
+                }
+            }
+        }
+        if (stack.length === 1) {
+            return stack[0];
+        }
+        else {
+            throw `There was a problem parsing: ${this._expression}`;
+        }
+    }
+}
+exports.NumExp = NumExp;
+
+
+/***/ }),
+
+/***/ "./src/maths/expressions/polynomexp.ts":
+/*!*********************************************!*\
+  !*** ./src/maths/expressions/polynomexp.ts ***!
+  \*********************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.PolynomExpProduct = exports.PolynomExpFactor = void 0;
+const algebra_1 = __webpack_require__(/*! ../algebra */ "./src/maths/algebra/index.ts");
+const coefficients_1 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
+class PolynomExpFactor {
+    constructor(polynom, degree, mathFunction) {
+        this._polynom = new algebra_1.Polynom(polynom);
+        this._degree = new coefficients_1.Fraction(degree === undefined ? 1 : degree);
+        this._fn = mathFunction;
+        this._powerAsInteger = true;
+        this._forceParenthesis = true;
+    }
+    _forceParenthesis;
+    get forceParenthesis() {
+        return this._forceParenthesis;
+    }
+    set forceParenthesis(value) {
+        this._forceParenthesis = value;
+    }
+    _fn;
+    get fn() {
+        return this._fn;
+    }
+    set fn(value) {
+        this._fn = value;
+    }
+    _powerAsInteger;
+    get powerAsInteger() {
+        return this._powerAsInteger;
+    }
+    set powerAsInteger(value) {
+        this._powerAsInteger = value;
+    }
+    _polynom;
+    get polynom() {
+        return this._polynom;
+    }
+    set polynom(value) {
+        this._polynom = value;
+    }
+    _degree;
+    get degree() {
+        return this._degree;
+    }
+    set degree(value) {
+        this._degree = value;
+    }
+    get tex() {
+        let tex;
+        if (this._degree.isOne() && (this._fn !== undefined || !this._forceParenthesis)) {
+            tex = this._polynom.tex;
+        }
+        else {
+            if (this._powerAsInteger && !this._degree.isRelative()) {
+                tex = `\\sqrt${this._degree.denominator !== 2 ? `[ ${this._degree.denominator} ]` : ''}{ ${this._polynom.tex} }^{ ${this._degree.numerator} }`;
+            }
+            else if (this.isCoefficient && this.firstCoefficient.isNatural()) {
+                tex = this._polynom.tex + this._texDegree;
+            }
+            else {
+                tex = `\\left( ${this._polynom.tex} \\right)${this._texDegree}`;
+            }
         }
+        if (this._fn !== undefined && this._fn.tex !== undefined) {
+            tex = `${this._fn.tex}\\left( ${tex} \\right)`;
+        }
+        return tex;
     }
-    get radical() {
-        return this._radical;
+    get isCoefficient() {
+        return this._polynom.degree().isZero();
     }
-    set radical(value) {
-        this._radical = value;
+    get firstCoefficient() {
+        return this._polynom.monomByDegree().coefficient;
     }
-    get nth() {
-        return this._nth;
+    get _texDegree() {
+        if (this._degree.isOne()) {
+            return '';
+        }
+        else {
+            return `^{ ${this._degree.tfrac} }`;
+        }
     }
-    set nth(value) {
-        if (Number.isSafeInteger(value) && value >= 2) {
-            this._nth = value;
+    setForceParenthesis(value) {
+        this._forceParenthesis = value === undefined || value;
+        return this;
+    }
+    derivative(letter) {
+        if (this._degree.isOne()) {
+            return new PolynomExpProduct(new PolynomExpFactor(this._polynom.clone().derivative(letter)));
         }
         else {
-            console.log('Error setting the nth root');
-            this._nth = 2;
+            return new PolynomExpProduct(new PolynomExpFactor(this._degree.clone()), new PolynomExpFactor(this._polynom.clone().derivative(letter)), new PolynomExpFactor(this._polynom.clone(), this._degree.clone().subtract(1)));
         }
     }
-    get coefficient() {
-        return this._coefficient;
+}
+exports.PolynomExpFactor = PolynomExpFactor;
+class PolynomExpProduct {
+    constructor(...values) {
+        this._factors = values || [];
+        this._positive = true;
+        this._asPositiveDegree = true;
     }
-    set coefficient(value) {
-        this._coefficient = value;
+    _fn;
+    get fn() {
+        return this._fn;
+    }
+    set fn(value) {
+        this._fn = value;
+    }
+    _factors;
+    get factors() {
+        return this._factors;
+    }
+    set factors(value) {
+        this._factors = value;
+    }
+    _positive;
+    get positive() {
+        return this._positive;
+    }
+    set positive(value) {
+        this._positive = value;
+    }
+    _asPositiveDegree;
+    get asPositiveDegree() {
+        return this._asPositiveDegree;
+    }
+    set asPositiveDegree(value) {
+        this._asPositiveDegree = value;
     }
     get tex() {
-        let C;
-        if (this._coefficient === 1) {
-            C = '';
+        let parenthesis = this._factors.length > 1;
+        let tex = this._factors.map(factor => factor.setForceParenthesis(parenthesis).tex).join(' \\cdot ');
+        if (this._asPositiveDegree) {
+            const numerators = this._factors.filter(x => x.degree.isPositive()), denominators = this._factors.filter(x => x.degree.isNegative());
+            let numeratorsAsTex, denominatorsAsTex;
+            if (denominators.length > 0) {
+                if (numerators.length === 0) {
+                    numeratorsAsTex = [1];
+                }
+                else if (numerators.length === 1) {
+                    numeratorsAsTex = [numerators[0].setForceParenthesis(false).tex];
+                }
+                else {
+                    parenthesis = numerators.length > 1;
+                    numeratorsAsTex = numerators.map(factor => factor.setForceParenthesis(parenthesis).tex);
+                }
+                denominators.map(x => x.degree.opposed());
+                if (denominators.length === 1) {
+                    denominatorsAsTex = [denominators[0].setForceParenthesis(false).tex];
+                }
+                else {
+                    parenthesis = denominators.length > 1;
+                    denominatorsAsTex = denominators.map(factor => factor.setForceParenthesis(parenthesis).tex);
+                }
+                denominators.map(x => x.degree.opposed());
+                tex = `\\dfrac{ ${numeratorsAsTex.join(' \\cdot ')} }{ ${denominatorsAsTex.join(' \\cdot ')} }`;
+            }
         }
-        else if (this._coefficient === -1) {
-            C = '-';
+        if (this._fn !== undefined && this._fn.name !== undefined && this._fn.name !== '') {
+            tex = `${this._fn.tex}\\left( ${tex} \\right)`;
         }
-        else {
-            C = this._coefficient.toString();
+        return tex;
+    }
+    reduce() {
+        let coefficients = this._factors.filter(factor => factor.isCoefficient), polynoms = this._factors.filter(factor => !factor.isCoefficient);
+        let result = new coefficients_1.Fraction().one();
+        if (coefficients.length > 1) {
+            for (const factor of coefficients) {
+                if (factor.degree.isPositive()) {
+                    result.multiply(factor.polynom.monoms[0].coefficient.pow(factor.degree));
+                }
+                else {
+                    result.divide(factor.polynom.monoms[0].coefficient.pow(factor.degree.clone().abs()));
+                }
+            }
         }
-        if (this._radical === 1) {
-            return `${this._coefficient}`;
+        else if (coefficients.length === 1) {
+            result = coefficients[0].polynom.monoms[0].coefficient;
+        }
+        if (result.isOne()) {
+            this._factors = [...polynoms];
+        }
+        else if (!result.isRelative()) {
+            this._factors = [
+                new PolynomExpFactor(result.numerator),
+                new PolynomExpFactor(result.denominator, -1),
+                ...polynoms
+            ];
         }
         else {
-            if (this._nth === 2) {
-                return `${C}\\sqrt{${this._radical}}`;
+            this._factors = [
+                new PolynomExpFactor(result),
+                ...polynoms
+            ];
+        }
+        return this;
+    }
+    integrate(letter) {
+        if (this._factors.length === 2) {
+            let d1 = this._factors[0].polynom.degree(letter).value, d2 = this._factors[1].polynom.degree(letter).value;
+            if (d1 === d2 + 1) {
+                return this._integrateWithInternalDerivative(this._factors[0], this._factors[1], letter);
             }
-            else {
-                return `${C}\\sqrt[${this._nth}]{${this._radical}}`;
+            else if (d1 + 1 === d2) {
+                return this._integrateWithInternalDerivative(this._factors[1], this._factors[0], letter);
             }
         }
+        return;
     }
-    get value() {
-        return this._coefficient * Math.pow(this._radical, 1 / this._nth);
-    }
-    parse = (radical, nthroot, coefficient) => {
-        this._coefficient = (coefficient === undefined) ? 1 : coefficient;
-        this._nth = (nthroot === undefined) ? 2 : nthroot;
-        this._radical = (radical === undefined) ? 1 : radical;
-        if (this._nth % 2 === 0 && this._radical < 0) {
-            this._isValid = false;
-        }
+    applyMathFunction(mathFn) {
+        this._fn = mathFn;
         return this;
-    };
-    reduce = () => {
-        let V = Math.floor(Math.pow(this._radical, 1 / this._nth));
-        while (V > 1) {
-            if (this._radical % Math.pow(V, this._nth) === 0) {
-                this._coefficient *= V;
-                this._radical = this._radical / Math.pow(V, this._nth);
-                V = Math.floor(Math.pow(this._radical, 1 / this._nth));
-                continue;
+    }
+    _integrateWithInternalDerivative(P, Pinternal, letter) {
+        let internalDerivative = P.polynom.clone().derivative(letter);
+        let { quotient, reminder } = Pinternal.polynom.clone().euclidian(internalDerivative);
+        if (reminder.isZero() && quotient.degree(letter).isZero()) {
+            if (P.degree.isEqual(-1)) {
+                return (new PolynomExpProduct(new PolynomExpFactor(quotient, 1), new PolynomExpFactor(P.polynom.clone(), 1, {
+                    name: 'ln', tex: '\\ln', fn: (x) => Math.log(x)
+                })));
+            }
+            else {
+                return new PolynomExpProduct(new PolynomExpFactor(P.degree.clone().add(1).invert(), 1), new PolynomExpFactor(quotient, 1), new PolynomExpFactor(P.polynom.clone(), P.degree.clone().add(1)));
             }
-            V--;
         }
-        return this;
-    };
-    multiply = (N) => {
-        this._radical *= N.radical;
-        return this.reduce();
-    };
-    hasRadical = () => {
-        return !(this._radical === 1 || this._radical === 0 || this._isValid === false);
-    };
+        return;
+    }
 }
-exports.Nthroot = Nthroot;
+exports.PolynomExpProduct = PolynomExpProduct;
 
 
 /***/ }),
@@ -3312,8 +3807,9 @@ const numeric_1 = __webpack_require__(/*! ../numeric */ "./src/maths/numeric.ts"
 var LinePropriety;
 (function (LinePropriety) {
     LinePropriety[LinePropriety["None"] = 0] = "None";
-    LinePropriety[LinePropriety["Parallel"] = 1] = "Parallel";
-    LinePropriety[LinePropriety["Perpendicular"] = 2] = "Perpendicular";
+    LinePropriety["Parallel"] = "parallel";
+    LinePropriety["Perpendicular"] = "perpendicular";
+    LinePropriety["Tangent"] = "tangent";
 })(LinePropriety || (LinePropriety = {}));
 class Line {
     _a;
@@ -4242,134 +4738,6 @@ class Numeric {
 exports.Numeric = Numeric;
 
 
-/***/ }),
-
-/***/ "./src/maths/numexp.ts":
-/*!*****************************!*\
-  !*** ./src/maths/numexp.ts ***!
-  \*****************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NumExp = void 0;
-const shutingyard_1 = __webpack_require__(/*! ./shutingyard */ "./src/maths/shutingyard.ts");
-const coefficients_1 = __webpack_require__(/*! ./coefficients */ "./src/maths/coefficients/index.ts");
-class NumExp {
-    _rpn;
-    _expression;
-    constructor(value) {
-        this._expression = value;
-        this._rpn = new shutingyard_1.Shutingyard(shutingyard_1.ShutingyardMode.NUMERIC).parse(value).rpn;
-    }
-    get rpn() {
-        return this._rpn;
-    }
-    get expression() {
-        return this._expression;
-    }
-    _extractDecimalPart(value) {
-        let decimal = value.toString();
-        if (!decimal.includes('.')) {
-            return '';
-        }
-        decimal = decimal.split('.')[1];
-        return decimal.substring(0, decimal.length - 2);
-    }
-    _numberCorrection(value) {
-        const epsilon = 0.00000000000001, number_of_digits = 6;
-        let decimal = this._extractDecimalPart(value);
-        if (decimal === '') {
-            return value;
-        }
-        const n9 = decimal.match(/9+$/g);
-        const n0 = decimal.match(/0+$/g);
-        if (n9 && n9[0].length >= number_of_digits) {
-            let mod = this._extractDecimalPart(value + epsilon), mod0 = mod.match(/0+$/g);
-            if (mod0 && mod0[0].length >= number_of_digits) {
-                return +((value + epsilon).toString().split(mod0[0])[0]);
-            }
-        }
-        if (n0 && n0[0].length >= number_of_digits) {
-            let mod = this._extractDecimalPart(value - epsilon), mod9 = mod.match(/9+$/g);
-            if (mod9 && mod9[0].length >= number_of_digits) {
-                return +(value.toString().split(n0[0])[0]);
-            }
-        }
-        return value;
-    }
-    _addToStack(stack, value) {
-        stack.push(this._numberCorrection(value));
-    }
-    evaluate(values) {
-        let stack = [];
-        for (const element of this._rpn) {
-            if (element.tokenType === shutingyard_1.ShutingyardType.COEFFICIENT) {
-                if (!isNaN(+element.token)) {
-                    this._addToStack(stack, +element.token);
-                }
-                else {
-                    this._addToStack(stack, new coefficients_1.Fraction(element.token).value);
-                }
-            }
-            else if (element.tokenType === shutingyard_1.ShutingyardType.VARIABLE) {
-                if (values[element.token] !== undefined) {
-                    this._addToStack(stack, +values[element.token]);
-                }
-            }
-            else if (element.tokenType === shutingyard_1.ShutingyardType.CONSTANT) {
-                this._addToStack(stack, shutingyard_1.tokenConstant[element.token]);
-            }
-            else if (element.tokenType === shutingyard_1.ShutingyardType.OPERATION) {
-                if (element.token === '*') {
-                    const b = +stack.pop(), a = +stack.pop();
-                    this._addToStack(stack, a * b);
-                }
-                else if (element.token === '/') {
-                    const b = +stack.pop(), a = +stack.pop();
-                    this._addToStack(stack, a / b);
-                }
-                else if (element.token === '+') {
-                    const b = +stack.pop(), a = +stack.pop();
-                    this._addToStack(stack, a + b);
-                }
-                else if (element.token === '-') {
-                    const b = +stack.pop(), a = +stack.pop() || 0;
-                    this._addToStack(stack, a - b);
-                }
-                else if (element.token === '^') {
-                    const b = +stack.pop(), a = +stack.pop();
-                    this._addToStack(stack, Math.pow(a, b));
-                }
-            }
-            else if (element.tokenType === shutingyard_1.ShutingyardType.FUNCTION) {
-                const a = +stack.pop();
-                if (element.token === 'sin') {
-                    this._addToStack(stack, Math.sin(a));
-                }
-                else if (element.token === 'cos') {
-                    this._addToStack(stack, Math.cos(a));
-                }
-                else if (element.token === 'tan') {
-                    this._addToStack(stack, Math.tan(a));
-                }
-                else if (element.token === 'sqrt') {
-                    this._addToStack(stack, Math.sqrt(a));
-                }
-            }
-        }
-        if (stack.length === 1) {
-            return stack[0];
-        }
-        else {
-            console.error('There was a problem parsing', this._expression, '. The RPN array is', this._rpn);
-            return 0;
-        }
-    }
-}
-exports.NumExp = NumExp;
-
-
 /***/ }),
 
 /***/ "./src/maths/random/index.ts":
@@ -4784,10 +5152,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;
         }
@@ -4827,9 +5191,7 @@ class Shutingyard {
             }
             if (token === '') {
                 if (expr[start].match(/[0-9]/)) {
-                    if (this._mode === ShutingyardMode.POLYNOM) {
-                        token = expr.substring(start).match(/^([0-9.,/]+)/)[0];
-                    }
+                    if (this._mode === ShutingyardMode.POLYNOM && false) {}
                     else {
                         token = expr.substring(start).match(/^([0-9.,]+)/)[0];
                     }
@@ -4993,7 +5355,7 @@ var exports = __webpack_exports__;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const numeric_1 = __webpack_require__(/*! ./maths/numeric */ "./src/maths/numeric.ts");
-const numexp_1 = __webpack_require__(/*! ./maths/numexp */ "./src/maths/numexp.ts");
+const numexp_1 = __webpack_require__(/*! ./maths/expressions/numexp */ "./src/maths/expressions/numexp.ts");
 const shutingyard_1 = __webpack_require__(/*! ./maths/shutingyard */ "./src/maths/shutingyard.ts");
 const random_1 = __webpack_require__(/*! ./maths/random */ "./src/maths/random/index.ts");
 const coefficients_1 = __webpack_require__(/*! ./maths/coefficients */ "./src/maths/coefficients/index.ts");
@@ -5012,6 +5374,8 @@ window.Pi = {
     Rational: algebra_1.Rational,
     Logicalset: algebra_1.Logicalset,
     Random: random_1.Random,
+    PolynomExpFactor: algebra_1.PolynomExpFactor,
+    PolynomExpProduct: algebra_1.PolynomExpProduct,
     Geometry: {
         Vector: geometry_1.Vector,
         Point: geometry_1.Point,