pimath 0.0.24 → 0.0.28

package/dev/pi.js

@@ -14,7 +14,6 @@ exports.Equation = void 0;
 const polynom_1 = __webpack_require__(/*! ./polynom */ "./src/maths/algebra/polynom.ts");
 const numeric_1 = __webpack_require__(/*! ../numeric */ "./src/maths/numeric.ts");
 const coefficients_1 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
-const coefficients_2 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
 class Equation {
     _left;
     _right;
@@ -28,16 +27,26 @@ class Equation {
         this._right = new polynom_1.Polynom().zero();
         this._sign = '=';
         if (equations.length === 1) {
-            if (equations[0].isEquation === true) {
+            if (equations[0] instanceof Equation) {
                 return equations[0].clone();
             }
-            else {
+            else if (typeof equations[0] === 'string') {
                 this.parse(equations[0]);
             }
         }
         else if (equations.length === 2) {
-            this.left = (equations[0] instanceof polynom_1.Polynom) ? equations[0].clone() : new polynom_1.Polynom(equations[0]);
-            this.right = (equations[1] instanceof polynom_1.Polynom) ? equations[1].clone() : new polynom_1.Polynom(equations[1]);
+            if (equations[0] instanceof polynom_1.Polynom) {
+                this.left = equations[0].clone();
+            }
+            else if (typeof equations[0] === 'string') {
+                this.left = new polynom_1.Polynom(equations[0]);
+            }
+            if (equations[1] instanceof polynom_1.Polynom) {
+                this.right = equations[1].clone();
+            }
+            else if (typeof equations[1] === 'string') {
+                this.right = new polynom_1.Polynom(equations[1]);
+            }
         }
         else {
             return this;
@@ -53,24 +62,24 @@ class Equation {
     get solution() {
         if (this._solutions.length === 1
             &&
-                (this._solutions[0] === this._real
-                    || this._solutions[0] === this._varnothing
-                    || this._solutions[0].includes('\\left'))) {
+                (this._solutions[0].tex === this._real
+                    || this._solutions[0].tex === this._varnothing
+                    || this._solutions[0].tex.includes('\\left'))) {
             return `S = ${this._solutions[0]}`;
         }
-        return `S = \\left{ ${this._solutions.join(';')} \\right}`;
+        return `S = \\left{ ${this._solutions.map(x => x.tex).join(';')} \\right}`;
     }
     get isReal() {
         if (this._solutions === undefined) {
             this.solve();
         }
-        return this._solutions[0] === this._real;
+        return this._solutions[0].tex === this._real;
     }
     get isVarnothing() {
         if (this._solutions === undefined) {
             this.solve();
         }
-        return this._solutions[0] === this._varnothing;
+        return this._solutions[0].tex === this._varnothing;
     }
     get signAsTex() {
         if (this._sign === '>=' || this._sign === '=>' || this._sign === 'geq') {
@@ -310,19 +319,19 @@ class Equation {
     letters = () => {
         return [...new Set([...this._left.letters(), ...this._right.letters()])];
     };
-    solve = (letter) => {
+    solve = () => {
         this._solutions = [];
         this._polynom = this._left.clone().subtract(this._right);
-        switch (this._polynom.degree(letter).value) {
+        switch (this._polynom.degree().value) {
             case 0:
             case 1:
-                this._solveDegree1(letter);
+                this._solveDegree1();
                 break;
             case 2:
-                this._solveDegree2(letter);
+                this._solveDegree2();
                 break;
             default:
-                this._solveDegree3plus(letter);
+                this._solveDegree3plus();
         }
         return this;
     };
@@ -347,19 +356,31 @@ class Equation {
         }
     };
     _solveDegree1 = (letter) => {
-        const m1 = this._polynom.monomByDegree(1, letter).coefficient, m0 = this._polynom.monomByDegree(0, letter).coefficient, v = m0.clone().opposed().divide(m1).display;
+        const m1 = this._polynom.monomByDegree(1, letter).coefficient, m0 = this._polynom.monomByDegree(0, letter).coefficient, v = m0.clone().opposed().divide(m1);
         let s;
         if (this.isStrictEqual()) {
             if (m1.value === 0) {
                 if (m0.value === 0) {
-                    this._solutions = [this._real];
+                    this._solutions = [{
+                            tex: this._real,
+                            value: NaN,
+                            exact: false
+                        }];
                 }
                 else {
-                    this._solutions = [this._varnothing];
+                    this._solutions = [{
+                            tex: this._varnothing,
+                            value: NaN,
+                            exact: false
+                        }];
                 }
             }
             else {
-                this._solutions = [v];
+                this._solutions = [{
+                        tex: v.display,
+                        value: v.value,
+                        exact: v
+                    }];
             }
         }
         else {
@@ -384,7 +405,11 @@ class Equation {
                     s = `\\left\\]-\\infty;${v} \\right\\${this.isAlsoEqual() ? '\\]' : '\\['}`;
                 }
             }
-            this._solutions = [s];
+            this._solutions = [{
+                    tex: s,
+                    value: NaN,
+                    exact: false
+                }];
         }
         return this._solutions;
     };
@@ -396,87 +421,161 @@ class Equation {
             realX2 = (-b + Math.sqrt(delta)) / (2 * a);
             if (delta > 1.0e5) {
                 this._solutions = [
-                    ((-b - Math.sqrt(delta)) / (2 * a)).toFixed(5),
-                    ((-b + Math.sqrt(delta)) / (2 * a)).toFixed(5)
+                    {
+                        tex: ((-b - Math.sqrt(delta)) / (2 * a)).toFixed(5),
+                        value: realX1,
+                        exact: false
+                    },
+                    {
+                        tex: ((-b + Math.sqrt(delta)) / (2 * a)).toFixed(5),
+                        value: realX2,
+                        exact: false
+                    }
                 ];
             }
             else {
-                nthDelta = new coefficients_2.Nthroot().parse(delta).reduce();
+                nthDelta = new coefficients_1.Nthroot(delta).reduce();
                 if (nthDelta.hasRadical()) {
                     let gcd = numeric_1.Numeric.gcd(b, 2 * a, nthDelta.coefficient);
                     nthDelta.coefficient = nthDelta.coefficient / gcd;
                     if (b !== 0) {
                         if (2 * a / gcd === 1) {
                             this._solutions = [
-                                `${-b / gcd} - ${nthDelta.tex}`,
-                                `${-b / gcd} + ${nthDelta.tex}`,
+                                {
+                                    tex: `${-b / gcd} - ${nthDelta.tex}`,
+                                    value: realX1,
+                                    exact: false
+                                },
+                                {
+                                    tex: `${-b / gcd} + ${nthDelta.tex}`,
+                                    value: realX2,
+                                    exact: false
+                                },
                             ];
                         }
                         else {
                             this._solutions = [
-                                `\\dfrac{${-b / gcd} - ${nthDelta.tex} }{ ${2 * a / gcd} }`,
-                                `\\dfrac{${-b / gcd} + ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                {
+                                    tex: `\\dfrac{${-b / gcd} - ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                    value: realX1,
+                                    exact: false
+                                },
+                                {
+                                    tex: `\\dfrac{${-b / gcd} + ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                    value: realX2,
+                                    exact: false
+                                },
                             ];
                         }
                     }
                     else {
                         if (2 * a / gcd === 1) {
                             this._solutions = [
-                                `- ${nthDelta.tex}`,
-                                `${nthDelta.tex}`,
+                                {
+                                    tex: `- ${nthDelta.tex}`,
+                                    value: realX1,
+                                    exact: false
+                                },
+                                {
+                                    tex: `${nthDelta.tex}`,
+                                    value: realX2,
+                                    exact: false
+                                },
                             ];
                         }
                         else {
                             this._solutions = [
-                                `\\dfrac{- ${nthDelta.tex} }{ ${2 * a / gcd} }`,
-                                `\\dfrac{${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                {
+                                    tex: `\\dfrac{- ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                    value: realX1,
+                                    exact: false
+                                },
+                                {
+                                    tex: `\\dfrac{${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                    value: realX2,
+                                    exact: false
+                                },
                             ];
                         }
                     }
                 }
                 else {
+                    const S1 = new coefficients_1.Fraction(-b - nthDelta.coefficient, 2 * a).reduce(), S2 = new coefficients_1.Fraction(-b + nthDelta.coefficient, 2 * a).reduce();
                     this._solutions = [
-                        new coefficients_1.Fraction(-b - nthDelta.coefficient, 2 * a).reduce().dfrac,
-                        new coefficients_1.Fraction(-b + nthDelta.coefficient, 2 * a).reduce().dfrac
+                        {
+                            tex: S1.dfrac,
+                            value: realX1,
+                            exact: S1
+                        },
+                        {
+                            tex: S2.dfrac,
+                            value: realX2,
+                            exact: S2
+                        }
                     ];
                 }
             }
         }
         else if (delta === 0) {
-            this._solutions = [new coefficients_1.Fraction(-b, 2 * a).reduce().dfrac];
+            const sol = new coefficients_1.Fraction(-b, 2 * a).reduce();
+            this._solutions = [{
+                    tex: sol.dfrac,
+                    value: sol.value,
+                    exact: sol
+                }];
         }
         else {
-            this._solutions = [this._varnothing];
+            this._solutions = [{
+                    tex: this._varnothing,
+                    value: NaN,
+                    exact: false
+                }];
         }
         if (!this.isStrictEqual()) {
             if (this._solutions.length === 2) {
-                sX1 = (realX1 < realX2) ? this._solutions[0] : this._solutions[1];
-                sX2 = (realX1 < realX2) ? this._solutions[1] : this._solutions[0];
+                sX1 = (realX1 < realX2) ? this._solutions[0].tex : this._solutions[1].tex;
+                sX2 = (realX1 < realX2) ? this._solutions[1].tex : this._solutions[0].tex;
                 if ((this.isGreater() && aF.sign() === 1) || (!this.isGreater() && aF.sign() === -1)) {
-                    this._solutions = [
-                        `\\left]-\\infty ; ${sX1}\\right${this.isAlsoEqual() ? ']' : '['} \\cup \\left${this.isAlsoEqual() ? '[' : ']'}${sX2};+\\infty\\right[`
+                    this._solutions = [{
+                            tex: `\\left]-\\infty ; ${sX1}\\right${this.isAlsoEqual() ? ']' : '['} \\cup \\left${this.isAlsoEqual() ? '[' : ']'}${sX2};+\\infty\\right[`,
+                            value: NaN,
+                            exact: false
+                        }
                     ];
                 }
                 else {
-                    this._solutions = [
-                        `\\left${this.isAlsoEqual() ? '[' : ']'}${sX1} ; ${sX2}\\right${this.isAlsoEqual() ? ']' : '['}`
-                    ];
+                    this._solutions = [{
+                            tex: `\\left${this.isAlsoEqual() ? '[' : ']'}${sX1} ; ${sX2}\\right${this.isAlsoEqual() ? ']' : '['}`,
+                            value: NaN,
+                            exact: false
+                        }];
                 }
             }
-            else if (this._solutions.length === 1 && this._solutions[0] !== this._varnothing) {
+            else if (this._solutions.length === 1 && this._solutions[0].tex !== this._varnothing) {
                 if (!this.isAlsoEqual()) {
                     if ((this.isGreater() && aF.sign() === 1) || (!this.isGreater() && aF.sign() === -1)) {
-                        this._solutions = [
-                            `\\left]-\\infty ; ${this._solutions[0]}\\right[ \\cup \\left]${this._solutions[0]};+\\infty\\right[`
+                        this._solutions = [{
+                                tex: `\\left]-\\infty ; ${this._solutions[0].tex}\\right[ \\cup \\left]${this._solutions[0].tex};+\\infty\\right[`,
+                                value: NaN,
+                                exact: false
+                            }
                         ];
                     }
                     else {
-                        this._solutions = [this._varnothing];
+                        this._solutions = [{
+                                tex: this._varnothing,
+                                value: NaN,
+                                exact: false
+                            }];
                     }
                 }
                 else {
                     if ((this.isGreater() && aF.sign() === 1) || (!this.isGreater() && aF.sign() === -1)) {
-                        this._solutions = [this._real];
+                        this._solutions = [{
+                                tex: this._real,
+                                value: NaN,
+                                exact: false
+                            }];
                     }
                     else {
                     }
@@ -484,17 +583,25 @@ class Equation {
             }
             else {
                 if (this.isGreater()) {
-                    this._solutions = [aF.sign() === 1 ? this._real : this._varnothing];
+                    this._solutions = [{
+                            tex: aF.sign() === 1 ? this._real : this._varnothing,
+                            value: NaN,
+                            exact: false
+                        }];
                 }
                 else {
-                    this._solutions = [aF.sign() === -1 ? this._real : this._varnothing];
+                    this._solutions = [{
+                            tex: aF.sign() === -1 ? this._real : this._varnothing,
+                            value: NaN,
+                            exact: false
+                        }];
                 }
             }
         }
         return this._solutions;
     };
-    _solveDegree3plus = (letter) => {
-        this._solutions = [letter];
+    _solveDegree3plus = () => {
+        this._solutions = [{ tex: 'solve x - not yet handled', value: NaN, exact: false }];
         return this._solutions;
     };
 }
@@ -557,9 +664,6 @@ class LinearSystem {
         }
         return this;
     }
-    get isLinearSystem() {
-        return true;
-    }
     get equations() {
         return this._equations;
     }
@@ -605,7 +709,7 @@ class LinearSystem {
         }
         return `\\left\\{\\begin{array}{${"r".repeat(letters.length)}cl}${equArray.join('\\\\\ ')}\\end{array}\\right.`;
     }
-    get texSolution() {
+    get solution() {
         let tex = [];
         if (this._solutions === undefined) {
             this.solve();
@@ -732,7 +836,7 @@ class LinearSystem {
         let E = this._resolutionSteps[this._resolutionSteps.length - 1].equations[0];
         E.solve();
         return {
-            value: new coefficients_1.Fraction(E.solutions[0]),
+            value: new coefficients_1.Fraction(E.solutions[0].value),
             isReal: E.isReal,
             isVarnothing: E.isVarnothing
         };
@@ -774,7 +878,7 @@ class Logicalset {
     }
     ;
     parse = (value) => {
-        this._rpn = new shutingyard_1.Shutingyard('set').parse(value).rpn;
+        this._rpn = new shutingyard_1.Shutingyard(shutingyard_1.ShutingyardMode.SET).parse(value).rpn;
         return this;
     };
     evaluate(tokenSets, reference) {
@@ -932,7 +1036,7 @@ class Monom {
         return this._coefficient;
     }
     set coefficient(F) {
-        this._coefficient = F;
+        this._coefficient = new coefficients_1.Fraction(F);
     }
     get literal() {
         return this._literal;
@@ -1071,6 +1175,12 @@ class Monom {
         let d = this.display;
         return (d[0] !== '-' ? '+' : '') + d;
     }
+    get texWithSign() {
+        if (this.coefficient.isStrictlyPositive()) {
+            return '+' + this.tex;
+        }
+        return this.tex;
+    }
     get tex() {
         let L = '', letters = Object.keys(this._literal).sort();
         for (let letter of letters) {
@@ -1105,7 +1215,21 @@ class Monom {
         }
     }
     parse = (inputStr) => {
-        this._shutingYardToReducedMonom(inputStr);
+        if (typeof inputStr === 'string') {
+            this._shutingYardToReducedMonom(inputStr);
+        }
+        else if (typeof inputStr === 'number') {
+            this._coefficient = new coefficients_1.Fraction(inputStr);
+            this._literal = {};
+        }
+        else if (inputStr instanceof coefficients_1.Fraction) {
+            this._coefficient = inputStr.clone();
+            this._literal = {};
+        }
+        else if (inputStr instanceof Monom) {
+            this._coefficient = inputStr._coefficient.clone();
+            this._literal = this.copyLiterals(inputStr.literal);
+        }
         return this;
     };
     _shutingYardToReducedMonom = (inputStr) => {
@@ -1176,6 +1300,13 @@ class Monom {
         }
         return F;
     };
+    copyLiterals = (literal) => {
+        let L = {};
+        for (let k in literal) {
+            L[k] = literal[k].clone();
+        }
+        return L;
+    };
     makeSame = (M) => {
         for (let k in M._literal) {
             this.setLetter(k, M._literal[k].clone());
@@ -1737,7 +1868,7 @@ class Polynom {
         else if (value instanceof monom_1.Monom) {
             return this.multiplyByMonom(value);
         }
-        else if (Number.isSafeInteger(value)) {
+        else if (Number.isSafeInteger(value) && typeof value === 'number') {
             return this.multiplyByInteger(value);
         }
         return this;
@@ -1778,7 +1909,7 @@ class Polynom {
         const degreeP = P.degree(letter);
         let newM;
         let MaxIteration = this.degree(letter).clone().multiply(2);
-        while (reminder.degree(letter) >= degreeP && MaxIteration.isPositive()) {
+        while (reminder.degree(letter).geq(degreeP) && MaxIteration.isPositive()) {
             MaxIteration.subtract(1);
             newM = reminder.monomByDegree(undefined, letter).clone().divide(maxMP);
             if (newM.isZero()) {
@@ -1790,10 +1921,10 @@ class Polynom {
         return { quotient, reminder };
     };
     divide = (value) => {
-        if (value.isFraction) {
+        if (value instanceof coefficients_1.Fraction) {
             this.divideByFraction(value);
         }
-        else if (Number.isSafeInteger(value)) {
+        else if (typeof value === 'number' && Number.isSafeInteger(value)) {
             return this.divideByInteger(value);
         }
     };
@@ -2289,7 +2420,7 @@ exports.Polynom = Polynom;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Rational = void 0;
 const polynom_1 = __webpack_require__(/*! ./polynom */ "./src/maths/algebra/polynom.ts");
-const fraction_1 = __webpack_require__(/*! ../coefficients/fraction */ "./src/maths/coefficients/fraction.ts");
+const coefficients_1 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
 class Rational {
     _rawString;
     _numerator;
@@ -2388,7 +2519,7 @@ class Rational {
             }
         }
         else {
-            return this._numerator.evaluate({ letter: new fraction_1.Fraction(value) }).divide(this._denominator.evaluate({ letter: new fraction_1.Fraction(value) }));
+            return this._numerator.evaluate({ letter: new coefficients_1.Fraction(value) }).divide(this._denominator.evaluate({ letter: new coefficients_1.Fraction(value) }));
         }
     };
 }
@@ -2516,7 +2647,7 @@ class Fraction {
                 }
                 break;
             case "object":
-                if (value.isFraction) {
+                if (value instanceof Fraction) {
                     this._numerator = +value.numerator;
                     this._denominator = +value.denominator;
                 }
@@ -2825,11 +2956,14 @@ class Nthroot {
     _nth;
     _coefficient;
     _isValid;
-    constructor() {
+    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;
@@ -2929,9 +3063,9 @@ const point_1 = __webpack_require__(/*! ./point */ "./src/maths/geometry/point.t
 const coefficients_1 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
 const algebra_1 = __webpack_require__(/*! ../algebra */ "./src/maths/algebra/index.ts");
 const vector_1 = __webpack_require__(/*! ./vector */ "./src/maths/geometry/vector.ts");
+const triangle_1 = __webpack_require__(/*! ./triangle */ "./src/maths/geometry/triangle.ts");
 class Circle {
     _center;
-    _radius;
     _squareRadius;
     _cartesian;
     _exists;
@@ -2944,6 +3078,12 @@ class Circle {
     get center() {
         return this._center;
     }
+    get exists() {
+        return this._exists;
+    }
+    get squareRadius() {
+        return this._squareRadius;
+    }
     get radius() {
         if (this._squareRadius.isSquare()) {
             return {
@@ -2960,20 +3100,25 @@ class Circle {
         return this._squareRadius;
     }
     get tex() {
-        let cx, cy;
-        if (this._center.x.isZero()) {
-            cx = 'x^2';
-        }
-        else {
-            cx = `\\left(x${this._center.x.isNegative() ? '+' : '-'}${this._center.x.clone().abs().tex}\\right)^2`;
-        }
-        if (this._center.y.isZero()) {
-            cy = 'y^2';
+        if (this._exists) {
+            let cx, cy;
+            if (this._center.x.isZero()) {
+                cx = 'x^2';
+            }
+            else {
+                cx = `\\left(x${this._center.x.isNegative() ? '+' : '-'}${this._center.x.clone().abs().tex}\\right)^2`;
+            }
+            if (this._center.y.isZero()) {
+                cy = 'y^2';
+            }
+            else {
+                cy = `\\left(y${this._center.y.isNegative() ? '+' : '-'}${this._center.y.clone().abs().tex}\\right)^2`;
+            }
+            return `${cx}+${cy}=${this._squareRadius.tex}`;
         }
         else {
-            cy = `\\left(y${this._center.y.isNegative() ? '+' : '-'}${this._center.y.clone().abs().tex}\\right)^2`;
+            return `\\text{le cercle n'existe pas.}`;
         }
-        return `${cx}+${cy}=${this._squareRadius.tex}`;
     }
     get developed() {
         return this._cartesian.tex;
@@ -2984,43 +3129,108 @@ class Circle {
     get cartesian() {
         return this._cartesian;
     }
+    clone() {
+        this._center = this._center.clone();
+        this._squareRadius = this._squareRadius.clone();
+        this._calculateCartesian();
+        return this;
+    }
+    _reset() {
+        this._center = null;
+        this._squareRadius = null;
+        this._cartesian = null;
+        this._exists = false;
+        return this;
+    }
     parse(...values) {
-        if (values.length === 1 && typeof values[0] === 'string') {
-            this.checkCircle(new algebra_1.Equation(values[0]));
+        this._reset();
+        if (typeof values[0] === 'string') {
+            this._parseEquation(new algebra_1.Equation(values[0]));
+        }
+        else if (values[0] instanceof algebra_1.Equation) {
+            this._parseEquation(values[0]);
         }
-        else if (values.length >= 2) {
-            this._center = new point_1.Point(values[0]);
+        else if (values[0] instanceof Circle) {
+            this._parseCopyCircle(values[0]);
+        }
+        else if (values[0] instanceof point_1.Point && values.length > 1) {
             if (values[1] instanceof point_1.Point) {
-                this._squareRadius = new vector_1.Vector(this._center, values[1]).normSquare;
-            }
-            else {
-                if (values[2] === true) {
-                    this._squareRadius = new coefficients_1.Fraction(values[1]);
+                if (values[2] instanceof point_1.Point) {
+                    this._parseThroughtThreePoints(values[0], values[1], values[2]);
                 }
                 else {
-                    this._radius = new coefficients_1.Fraction(values[1]);
-                    this._squareRadius = this._radius.clone().pow(2);
+                    this._parseCenterAndPointThrough(values[0], values[1]);
                 }
             }
-            this._cartesian = (new algebra_1.Equation(new algebra_1.Polynom(`(x-(${this._center.x.display}))^2+(y-(${this._center.y.display}))^2`), new algebra_1.Polynom(`${this._squareRadius.display}`))).moveLeft();
+            else if (values[1] instanceof coefficients_1.Fraction || typeof values[1] === 'number') {
+                this._parseCenterAndRadius(values[0], values[1], (typeof values[2] === "boolean") ? values[2] : false);
+            }
+        }
+        if (this._exists) {
+            this._calculateCartesian();
+            if (this._squareRadius !== undefined && this._squareRadius.isNegative()) {
+                this._exists = false;
+            }
+        }
+        return this;
+    }
+    _calculateCartesian() {
+        this._cartesian = (new algebra_1.Equation(new algebra_1.Polynom(`(x-(${this._center.x.display}))^2+(y-(${this._center.y.display}))^2`), new algebra_1.Polynom(`${this._squareRadius.display}`))).moveLeft();
+    }
+    _parseCopyCircle(circle) {
+        this._center = circle.center.clone();
+        this._squareRadius = circle.squareRadius.clone();
+        this._calculateCartesian();
+        this._exists = circle.exists;
+        return this;
+    }
+    _parseCenterAndRadius(center, radius, square) {
+        this._center = center.clone();
+        if (square) {
+            this._squareRadius = (new coefficients_1.Fraction(radius));
         }
+        else {
+            this._squareRadius = new coefficients_1.Fraction(radius).pow(2);
+        }
+        this._exists = true;
+        return this;
+    }
+    _parseCenterAndPointThrough(center, pointThrough) {
+        this._center = center.clone();
+        this._squareRadius = new vector_1.Vector(this._center, pointThrough).normSquare;
+        this._exists = true;
+        return this;
     }
-    checkCircle = (P) => {
-        if (P.degree('x').value === 2 && P.degree('y').value === 2) {
-            let x2 = P.left.monomByDegree(2, 'x'), y2 = P.left.monomByDegree(2, 'y'), x1, y1, c;
+    _parseEquation(equ) {
+        this._exists = false;
+        equ.moveLeft();
+        if (equ.degree('x').value === 2 && equ.degree('y').value === 2) {
+            let x2 = equ.left.monomByDegree(2, 'x'), y2 = equ.left.monomByDegree(2, 'y'), x1, y1, c;
             if (x2.coefficient.isEqual(y2.coefficient)) {
-                P.divide(x2.coefficient);
-                x1 = P.left.monomByDegree(1, 'x');
-                y1 = P.left.monomByDegree(1, 'y');
-                c = P.left.monomByDegree(0);
+                equ.divide(x2.coefficient);
+                x1 = equ.left.monomByDegree(1, 'x');
+                y1 = equ.left.monomByDegree(1, 'y');
+                c = equ.left.monomByDegree(0);
                 this._center = new point_1.Point(x1.coefficient.clone().divide(2).opposed(), y1.coefficient.clone().divide(2).opposed());
                 this._squareRadius = c.coefficient.clone().opposed()
                     .add(this._center.x.clone().pow(2))
                     .add(this._center.y.clone().pow(2));
+                this._calculateCartesian();
+                this._exists = true;
+            }
+            else {
+                this._center = null;
+                this._squareRadius = null;
+                this._exists = false;
             }
         }
-        return false;
-    };
+        return this;
+    }
+    _parseThroughtThreePoints(A, B, C) {
+        let T = new triangle_1.Triangle(A, B, C), mAB = T.remarquables.mediators.AB.clone(), mAC = T.remarquables.mediators.AC.clone();
+        this.parse(mAB.intersection(mAC).point, A);
+        return this;
+    }
     relativePosition = (L) => {
         let distance = L.distanceTo(this.center), radius = Math.sqrt(this._squareRadius.value);
         if (distance.value - radius > 0.0000000001) {
@@ -3034,13 +3244,23 @@ class Circle {
         }
     };
     lineIntersection = (L) => {
-        let P1, P2;
-        const equ = this._cartesian.clone(), yLine = L.equation.clone().isolate('y');
-        if (yLine instanceof algebra_1.Equation) {
-            equ.replaceBy('y', yLine.right);
-            equ.solve();
+        let intersectionPoints = [], solX;
+        if (this._cartesian === null) {
+            return [];
+        }
+        const equX = this._cartesian.clone(), lineX = L.equation.clone().isolate('x'), lineY = L.equation.clone().isolate('y');
+        if (lineX instanceof algebra_1.Equation && lineY instanceof algebra_1.Equation) {
+            equX.replaceBy('y', lineY.right).simplify();
+            equX.solve();
+            for (let x of equX.solutions) {
+                if (x.exact === false && isNaN(x.value)) {
+                    continue;
+                }
+                solX = new coefficients_1.Fraction(x.exact === false ? x.value : x.exact);
+                intersectionPoints.push(new point_1.Point(solX.clone(), lineY.right.evaluate(solX)));
+            }
         }
-        return [];
+        return intersectionPoints;
     };
 }
 exports.Circle = Circle;
@@ -3114,9 +3334,6 @@ class Line {
         }
         return this;
     }
-    get isLine() {
-        return true;
-    }
     get exists() {
         return this._exists;
     }
@@ -3431,23 +3648,24 @@ exports.Line = Line;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Point = void 0;
-const fraction_1 = __webpack_require__(/*! ../coefficients/fraction */ "./src/maths/coefficients/fraction.ts");
+const coefficients_1 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
+class PointXY {
+    x;
+    y;
+}
 class Point {
     _x;
     _y;
     _exist;
     constructor(...values) {
-        this._x = new fraction_1.Fraction().zero();
-        this._y = new fraction_1.Fraction().zero();
+        this._x = new coefficients_1.Fraction().zero();
+        this._y = new coefficients_1.Fraction().zero();
         if (values !== undefined) {
             this.parse(...values);
         }
         return this;
     }
     ;
-    get isPoint() {
-        return true;
-    }
     get x() {
         return this._x;
     }
@@ -3486,22 +3704,24 @@ class Point {
             if (typeof values[0] === 'string') {
                 let xy = values[0].split(',');
                 if (xy.length === 2) {
-                    this._x = new fraction_1.Fraction(xy[0]).reduce();
-                    this._y = new fraction_1.Fraction(xy[1]).reduce();
+                    this._x = new coefficients_1.Fraction(xy[0]).reduce();
+                    this._y = new coefficients_1.Fraction(xy[1]).reduce();
                     return this;
                 }
             }
-            if (values[0].x !== undefined && values[0].y !== undefined) {
-                this._x = new fraction_1.Fraction(values[0].x).reduce();
-                this._y = new fraction_1.Fraction(values[0].y).reduce();
+            if (values[0] instanceof PointXY) {
+                this._x = new coefficients_1.Fraction(values[0].x).reduce();
+                this._y = new coefficients_1.Fraction(values[0].y).reduce();
+                return this;
             }
             else {
                 return this.zero();
             }
         }
         if (values.length === 2) {
-            this._x = new fraction_1.Fraction(values[0]).reduce();
-            this._y = new fraction_1.Fraction(values[1]).reduce();
+            this._x = new coefficients_1.Fraction(values[0]).reduce();
+            this._y = new coefficients_1.Fraction(values[1]).reduce();
+            return this;
         }
         return this;
     };
@@ -3511,8 +3731,8 @@ class Point {
         return this;
     };
     zero = () => {
-        this._x = new fraction_1.Fraction(null);
-        this._y = new fraction_1.Fraction(null);
+        this._x = new coefficients_1.Fraction(null);
+        this._y = new coefficients_1.Fraction(null);
         return this;
     };
     origin = () => {
@@ -3571,7 +3791,6 @@ class Triangle {
         }
         return this;
     }
-    get isTriangle() { return true; }
     get A() {
         return this._A;
     }
@@ -3635,7 +3854,7 @@ class Triangle {
             if (values.filter((x) => typeof x === 'string').length === 3) {
                 return this.parse(...values.map((x) => new line_1.Line(x)));
             }
-            else if (values.filter((x) => x.isLine === true).length === 3) {
+            else if (values.filter((x) => x instanceof line_1.Line).length === 3) {
                 this._lines = {
                     'AB': values[0],
                     'BC': values[1],
@@ -3664,7 +3883,7 @@ class Triangle {
                 }
             }
             else {
-                if (values.filter((x) => x.isPoint === true).length < 3) {
+                if (values.filter((x) => (x instanceof point_1.Point)).length < 3) {
                     return this.parse(new point_1.Point(values[0]), new point_1.Point(values[1]), new point_1.Point(values[2]));
                 }
                 this._A = values[0].clone();
@@ -3678,7 +3897,7 @@ class Triangle {
             }
         }
         else if (values.length === 1) {
-            if (values[0].isTriangle === true) {
+            if (values[0] instanceof Triangle) {
                 return values[0].clone();
             }
         }
@@ -3795,6 +4014,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Vector = void 0;
 const fraction_1 = __webpack_require__(/*! ../coefficients/fraction */ "./src/maths/coefficients/fraction.ts");
 const numeric_1 = __webpack_require__(/*! ../numeric */ "./src/maths/numeric.ts");
+const point_1 = __webpack_require__(/*! ./point */ "./src/maths/geometry/point.ts");
 class Vector {
     _x;
     _y;
@@ -3841,7 +4061,7 @@ class Vector {
             }
         }
         if (values.length >= 2) {
-            if (values[0].isPoint && values[1].isPoint) {
+            if (values[0] instanceof point_1.Point && values[1] instanceof point_1.Point) {
                 this._x = values[1].x.clone().subtract(values[0].x);
                 this._y = values[1].y.clone().subtract(values[0].y);
                 return this;
@@ -4014,6 +4234,131 @@ 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();
+                    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));
+                }
+            }
+        }
+        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":
@@ -4131,6 +4476,7 @@ class rndFraction extends randomCore_1.randomCore {
         super();
         this._defaultConfig = {
             negative: true,
+            max: 10,
             reduced: true,
             zero: true,
             natural: false
@@ -4140,16 +4486,16 @@ class rndFraction extends randomCore_1.randomCore {
     generate = () => {
         let Q = new coefficients_1.Fraction();
         if (this._config.negative) {
-            Q.numerator = index_1.Random.numberSym(10, this._config.zero);
+            Q.numerator = index_1.Random.numberSym(this._config.max, this._config.zero);
         }
         else {
-            Q.numerator = index_1.Random.number(this._config.zero ? 0 : 1, 10);
+            Q.numerator = index_1.Random.number(this._config.zero ? 0 : 1, this._config.max);
         }
         if (this._config.natural) {
             Q.denominator = 1;
         }
         else {
-            Q.denominator = index_1.Random.number(1, 10);
+            Q.denominator = index_1.Random.number(1, this._config.max);
         }
         return this._config.reduced ? Q.reduce() : Q;
     };
@@ -4228,7 +4574,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.rndMonom = void 0;
 const randomCore_1 = __webpack_require__(/*! ./randomCore */ "./src/maths/random/randomCore.ts");
 const index_1 = __webpack_require__(/*! ./index */ "./src/maths/random/index.ts");
-const monom_1 = __webpack_require__(/*! ../algebra/monom */ "./src/maths/algebra/monom.ts");
+const algebra_1 = __webpack_require__(/*! ../algebra */ "./src/maths/algebra/index.ts");
 class rndMonom extends randomCore_1.randomCore {
     constructor(userConfig) {
         super();
@@ -4241,12 +4587,17 @@ class rndMonom extends randomCore_1.randomCore {
         this._config = this.mergeConfig(userConfig, this._defaultConfig);
     }
     generate = () => {
-        let M = new monom_1.Monom();
-        M.coefficient = index_1.Random.fraction({
-            zero: this._config.zero,
-            reduced: true,
-            natural: !this._config.fraction
-        });
+        let M = new algebra_1.Monom();
+        if (typeof this._config.fraction === "boolean") {
+            M.coefficient = index_1.Random.fraction({
+                zero: this._config.zero,
+                reduced: true,
+                natural: !this._config.fraction
+            });
+        }
+        else {
+            M.coefficient = index_1.Random.fraction(this._config.fraction);
+        }
         if (this._config.letters.length > 1) {
             for (let L of this._config.letters.split('')) {
                 M.setLetter(L, 0);
@@ -4291,7 +4642,8 @@ class rndPolynom extends randomCore_1.randomCore {
             unit: false,
             factorable: false,
             allowNullMonom: true,
-            numberOfMonoms: 0
+            numberOfMonoms: 0,
+            positive: true
         };
         this._config = this.mergeConfig(userConfig, this._defaultConfig);
     }
@@ -4312,8 +4664,13 @@ class rndPolynom extends randomCore_1.randomCore {
             }
             P.add(M);
         }
+        if (this._config.positive && P.monomByDegree().coefficient.isNegative()) {
+            P.monomByDegree().coefficient.opposed();
+        }
         if (this._config.numberOfMonoms > 0 && this._config.numberOfMonoms < P.length) {
-            P.monoms = index_1.Random.array(P.monoms, this._config.numberOfMonoms);
+            let M = P.monomByDegree().clone();
+            P.monoms = index_1.Random.array(P.monoms.slice(1), this._config.numberOfMonoms - 1);
+            P.add(M).reorder().reduce();
         }
         return P;
     };
@@ -4353,46 +4710,75 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Shutingyard = void 0;
+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["POLYNOM"] = "polynom";
+    ShutingyardMode["SET"] = "set";
+    ShutingyardMode["NUMERIC"] = "numeric";
+})(ShutingyardMode = exports.ShutingyardMode || (exports.ShutingyardMode = {}));
 class Shutingyard {
     _rpn = [];
     _mode;
     _tokenConfig;
+    _tokenConstant;
     _uniformize;
+    _tokenKeys;
     constructor(mode) {
-        this._mode = typeof mode === 'undefined' ? 'polynom' : mode;
+        this._mode = typeof mode === 'undefined' ? ShutingyardMode.POLYNOM : mode;
         this.tokenConfigInitialization();
     }
-    isOperation(token) {
-        if (token[0].match(/[+\-*/^]/g)) {
-            return true;
-        }
-        return false;
-    }
     tokenConfigInitialization() {
-        if (this._mode === 'set') {
+        if (this._mode === ShutingyardMode.SET) {
             this._tokenConfig = {
-                '&': { precedence: 3, associative: 'left' },
-                '|': { precedence: 3, associative: 'left' },
-                '!': { precedence: 4, associative: 'right' },
-                '-': { precedence: 2, associative: 'left' }
+                '&': { 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 },
+            };
+        }
         else {
             this._tokenConfig = {
-                '^': { precedence: 4, associative: 'right' },
-                '*': { precedence: 3, associative: 'left' },
-                '/': { precedence: 3, associative: 'left' },
-                '+': { precedence: 2, associative: 'left' },
-                '-': { precedence: 2, associative: 'left' },
-                '%': { precedence: 3, associative: 'right' },
-                'sin': { precedence: 4, associative: 'right' },
-                'cos': { precedence: 4, associative: 'right' },
-                'tab': { precedence: 4, associative: 'right' },
+                '^': { 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 },
             };
             this._uniformize = true;
         }
+        this._tokenKeys = Object.keys(this._tokenConfig).sort((a, b) => b.length - a.length);
         return this._tokenConfig;
     }
     NextToken2(expr, start) {
@@ -4412,75 +4798,43 @@ class Shutingyard {
             tokenType = 'function-argument';
         }
         else {
-            const keys = Object.keys(this._tokenConfig).sort((a, b) => b.length - a.length);
-            for (let key of keys) {
-                if (expr.substr(start, key.length) === key) {
+            for (let key of this._tokenKeys) {
+                if (expr.substring(start, start + key.length) === key) {
                     token += key;
-                    tokenType = 'operation';
+                    tokenType = this._tokenConfig[key].type;
+                    break;
+                }
+            }
+            for (let key in exports.tokenConstant) {
+                if (expr.substring(start, start + key.length) === key) {
+                    token += key;
+                    tokenType = ShutingyardType.CONSTANT;
                     break;
                 }
             }
             if (token === '') {
                 if (expr[start].match(/[0-9]/)) {
-                    token = expr.substr(start).match(/^([0-9.,/]+)/)[0];
-                    tokenType = 'coefficient';
+                    if (this._mode === ShutingyardMode.POLYNOM) {
+                        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.substr(start).match(/^([a-zA-Z])/)[0];
-                    tokenType = 'variable';
+                    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 = 'monom';
+                    tokenType = ShutingyardType.MONOM;
                 }
             }
         }
         return [token, start + token.length, tokenType];
     }
-    NextToken(expr, start) {
-        let tokenMatch, token, tokenType;
-        this.NextToken2(expr, start);
-        tokenMatch = (expr.substr(start).match(/^[0-9/a-zA-Z^]+/g)) || [];
-        if (expr.substr(start, start + 3).match(/^(sin|cos|tan)/g)) {
-            token = expr.substr(start, 3);
-            tokenType = 'function';
-        }
-        else if (tokenMatch.length > 0) {
-            token = tokenMatch[0];
-            tokenType = 'monom';
-        }
-        else if (expr[start].match(/[+\-*/^]/g)) {
-            token = expr[start];
-            tokenType = 'operation';
-        }
-        else if (expr[start].match(/[&|!]/g)) {
-            token = expr[start];
-            tokenType = 'operation';
-        }
-        else if (expr[start] === '(') {
-            token = '(';
-            tokenType = '(';
-        }
-        else if (expr[start] === ')') {
-            token = ')';
-            tokenType = ')';
-        }
-        else if (expr[start] === ',') {
-            token = ',';
-            tokenType = 'function-argument';
-        }
-        else {
-            token = tokenMatch[0];
-            tokenType = 'monom';
-            if (token === '') {
-                token = expr[start];
-                tokenType = 'monom';
-                console.log('SHUTING YARD - NEXT TOKEN: error at ', start);
-            }
-        }
-        return [token, start + token.length, tokenType];
-    }
     Uniformizer(expr) {
         if (!this._uniformize) {
             return expr;
@@ -4513,6 +4867,7 @@ class Shutingyard {
                 case 'monom':
                 case 'coefficient':
                 case 'variable':
+                case 'constant':
                     outQueue.push({
                         token,
                         tokenType
@@ -4625,6 +4980,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 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");
@@ -4633,6 +4989,7 @@ const geometry_1 = __webpack_require__(/*! ./maths/geometry */ "./src/maths/geom
 window.Pi = {
     ShutingYard: shutingyard_1.Shutingyard,
     Numeric: numeric_1.Numeric,
+    NumExp: numexp_1.NumExp,
     Fraction: coefficients_1.Fraction,
     Root: coefficients_1.Nthroot,
     Monom: algebra_1.Monom,