pimath 0.0.49 → 0.0.53

package/dist/pi.js

@@ -1,11 +1,11 @@
-/******/ (() => { // webpackBootstrap
-/******/ 	"use strict";
-/******/ 	var __webpack_modules__ = ({
-
-/***/ 607:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-var __webpack_unused_export__;
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 607:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+var __webpack_unused_export__;
 
 __webpack_unused_export__ = ({ value: true });
 exports.l = void 0;
@@ -14,7 +14,7 @@ const numexp_1 = __webpack_require__(735);
 const shutingyard_1 = __webpack_require__(505);
 const random_1 = __webpack_require__(330);
 const fraction_1 = __webpack_require__(506);
-const nthroot_1 = __webpack_require__(923);
+const nthRoot_1 = __webpack_require__(872);
 const monom_1 = __webpack_require__(937);
 const polynom_1 = __webpack_require__(38);
 const equation_1 = __webpack_require__(760);
@@ -33,7 +33,7 @@ exports.l = {
     Numeric: numeric_1.Numeric,
     NumExp: numexp_1.NumExp,
     Fraction: fraction_1.Fraction,
-    Root: nthroot_1.Nthroot,
+    Root: nthRoot_1.NthRoot,
     Monom: monom_1.Monom,
     Polynom: polynom_1.Polynom,
     Equation: equation_1.Equation,
@@ -52,20 +52,25 @@ exports.l = {
     }
 };
 window.Pi = exports.l;
-
-
-/***/ }),
-
-/***/ 760:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 760:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Equation = void 0;
+exports.Equation = exports.PARTICULAR_SOLUTION = void 0;
 const polynom_1 = __webpack_require__(38);
 const numeric_1 = __webpack_require__(956);
 const fraction_1 = __webpack_require__(506);
-const nthroot_1 = __webpack_require__(923);
+const nthRoot_1 = __webpack_require__(872);
+var PARTICULAR_SOLUTION;
+(function (PARTICULAR_SOLUTION) {
+    PARTICULAR_SOLUTION["real"] = "\\mathbb{R}";
+    PARTICULAR_SOLUTION["varnothing"] = "\\varnothing";
+})(PARTICULAR_SOLUTION = exports.PARTICULAR_SOLUTION || (exports.PARTICULAR_SOLUTION = {}));
 class Equation {
     /**
      * Create an Equation using two polynoms.
@@ -74,8 +79,11 @@ class Equation {
      */
     constructor(...equations) {
         // Undetermined texSolutions.
-        this._varnothing = '\\varnothing';
-        this._real = '\\mathbb{R}';
+        this._varnothing = PARTICULAR_SOLUTION.varnothing;
+        this._real = PARTICULAR_SOLUTION.real;
+        this.hasVariable = (letter) => {
+            return this.variables.includes(letter);
+        };
         // ------------------------------------------
         // Creation / parsing functions
         // -----------------------------------------------
@@ -270,6 +278,8 @@ class Equation {
                 default:
                     this._solveDegree3plus();
             }
+            // cleanup the solutions.
+            this._solutions = Equation.makeSolutionsUnique(this._solutions);
             return this;
         };
         this.test = (values) => {
@@ -400,7 +410,7 @@ class Equation {
                 }
                 else {
                     this._solutions = [{
-                            tex: v.display,
+                            tex: v.tex,
                             value: v.value,
                             exact: v
                         }];
@@ -460,7 +470,7 @@ class Equation {
                     ];
                 }
                 else {
-                    nthDelta = new nthroot_1.Nthroot(delta).reduce();
+                    nthDelta = new nthRoot_1.NthRoot(delta).reduce();
                     if (nthDelta.hasRadical()) {
                         // -b +- coeff\sqrt{radical}
                         // -------------------------
@@ -487,12 +497,12 @@ class Equation {
                             else {
                                 this._solutions = [
                                     {
-                                        tex: `\\dfrac{${-b / gcd} - ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                        tex: `\\frac{${-b / gcd} - ${nthDelta.tex} }{ ${2 * a / gcd} }`,
                                         value: realX1,
                                         exact: false
                                     },
                                     {
-                                        tex: `\\dfrac{${-b / gcd} + ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                        tex: `\\frac{${-b / gcd} + ${nthDelta.tex} }{ ${2 * a / gcd} }`,
                                         value: realX2,
                                         exact: false
                                     },
@@ -517,12 +527,12 @@ class Equation {
                             else {
                                 this._solutions = [
                                     {
-                                        tex: `\\dfrac{- ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                        tex: `\\frac{- ${nthDelta.tex} }{ ${2 * a / gcd} }`,
                                         value: realX1,
                                         exact: false
                                     },
                                     {
-                                        tex: `\\dfrac{${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                        tex: `\\frac{${nthDelta.tex} }{ ${2 * a / gcd} }`,
                                         value: realX2,
                                         exact: false
                                     },
@@ -535,12 +545,12 @@ class Equation {
                         const S1 = new fraction_1.Fraction(-b - nthDelta.coefficient, 2 * a).reduce(), S2 = new fraction_1.Fraction(-b + nthDelta.coefficient, 2 * a).reduce();
                         this._solutions = [
                             {
-                                tex: S1.dfrac,
+                                tex: S1.frac,
                                 value: realX1,
                                 exact: S1
                             },
                             {
-                                tex: S2.dfrac,
+                                tex: S2.frac,
                                 value: realX2,
                                 exact: S2
                             }
@@ -551,7 +561,7 @@ class Equation {
             else if (delta === 0) {
                 const sol = new fraction_1.Fraction(-b, 2 * a).reduce();
                 this._solutions = [{
-                        tex: sol.dfrac,
+                        tex: sol.frac,
                         value: sol.value,
                         exact: sol
                     }];
@@ -634,9 +644,27 @@ class Equation {
             }
             return this._solutions;
         };
-        this._solveDegree3plus = () => {
-            // TODO: try to resolve equations with a degree superior than 2.
-            this._solutions = [{ tex: 'solve x - not yet handled', value: NaN, exact: false }]; // ESLint remove system :(
+        this._solveDegree3plus = (letter) => {
+            // Push everything to the left
+            // factorize
+            // solve each factors.
+            let equ = this.clone().moveLeft();
+            equ.left.factorize();
+            this._solutions = [];
+            equ.left.factors.forEach(factor => {
+                if (factor.degree(letter).leq(2)) {
+                    let factorAsEquation = new Equation(factor, 0);
+                    factorAsEquation.solve();
+                    factorAsEquation.solutions.forEach(solution => {
+                        this._solutions.push(solution);
+                    });
+                }
+                else {
+                    console.log(factor.tex, ': cannot actually get the solution of this equation');
+                }
+            });
+            // TODO: check equation resolution for more than degree 2
+            // this._solutions = [{tex: 'solve x - not yet handled', value: NaN, exact: false}];  // ESLint remove system :(
             return this._solutions;
         };
         // Default equation
@@ -751,15 +779,30 @@ class Equation {
     set randomizeDefaults(value) {
         this._randomizeDefaults = value;
     }
+    static makeSolutionsUnique(solutions, sorted) {
+        let solutionAsTex = [], uniqueSolutions = solutions.filter(sol => {
+            if (!solutionAsTex.includes(sol.tex)) {
+                solutionAsTex.push(sol.tex);
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+        if (sorted === true) {
+            uniqueSolutions.sort((a, b) => a.value - b.value);
+        }
+        return uniqueSolutions;
+    }
 }
 exports.Equation = Equation;
-
-
-/***/ }),
-
-/***/ 554:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 554:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.LinearSystem = void 0;
@@ -974,7 +1017,7 @@ class LinearSystem {
                 console.log(`Undefined (letter ${letter})`);
                 return;
             }
-            tex.push(this._solutions[letter].value.dfrac);
+            tex.push(this._solutions[letter].value.frac);
         }
         return `(${tex.join(';')})`;
     }
@@ -1020,13 +1063,13 @@ class LinearSystem {
     }
 }
 exports.LinearSystem = LinearSystem;
-
-
-/***/ }),
-
-/***/ 236:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 236:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 /**
  * Polynom module contains everything necessary to handle polynoms.
@@ -1184,13 +1227,13 @@ class Logicalset {
     }
 }
 exports.Logicalset = Logicalset;
-
-
-/***/ }),
-
-/***/ 937:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 937:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Monom = void 0;
@@ -1900,7 +1943,7 @@ class Monom {
         if (L === '') {
             // No setLetter - means it's only a number !
             if (this._coefficient.value != 0) {
-                return `${this._coefficient.dfrac}`;
+                return `${this._coefficient.frac}`;
             }
             else {
                 return '0';
@@ -1917,7 +1960,7 @@ class Monom {
                 return '0';
             }
             else {
-                return `${this._coefficient.dfrac}${L}`;
+                return `${this._coefficient.frac}${L}`;
             }
         }
     }
@@ -2026,13 +2069,13 @@ Monom.xmultiply = (...monoms) => {
     }
     return M;
 };
-
-
-/***/ }),
-
-/***/ 38:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 38:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 /**
  * Polynom module contains everything necessary to handle polynoms.*
@@ -2043,6 +2086,7 @@ const monom_1 = __webpack_require__(937);
 const shutingyard_1 = __webpack_require__(505);
 const numeric_1 = __webpack_require__(956);
 const fraction_1 = __webpack_require__(506);
+const equation_1 = __webpack_require__(760);
 /**
  * Polynom class can handle polynoms, reorder, resolve, ...
  * ```
@@ -2069,8 +2113,15 @@ class Polynom {
             if (typeof inputStr === 'string') {
                 return this._parseString(inputStr, ...values);
             }
-            else if (typeof inputStr === 'number' || inputStr instanceof fraction_1.Fraction || inputStr instanceof monom_1.Monom) {
+            else if ((typeof inputStr === 'number' || inputStr instanceof fraction_1.Fraction || inputStr instanceof monom_1.Monom)
+                && (values === undefined || values.length === 0)) {
+                this._monoms.push(new monom_1.Monom(inputStr));
+            }
+            else if (inputStr instanceof monom_1.Monom && values.length > 0) {
                 this._monoms.push(new monom_1.Monom(inputStr));
+                values.forEach(m => {
+                    this._monoms.push(new monom_1.Monom(m));
+                });
             }
             else if (inputStr instanceof Polynom) {
                 for (const m of inputStr.monoms) {
@@ -2545,105 +2596,148 @@ class Polynom {
                 P = P.euclidian(tempPolynom).quotient;
             }
             let securityLoop = P.degree().clone().multiply(2).value;
+            let result;
             // securityLoop = 0
             while (securityLoop >= 0) {
                 securityLoop--;
                 if (P.monoms.length < 2) {
                     if (!P.isOne()) {
                         factors.push(P.clone());
+                        P.one();
                     }
                     break;
                 }
+                else if (P.degree(letter).isOne()) {
+                    factors.push(P.clone());
+                    P.one();
+                    break;
+                }
                 else {
-                    // Get the first and last monom.
+                    // Get the first and last monom and build all their dividers.
                     let m1 = P.monoms[0].dividers, m2 = P.monoms[P.monoms.length - 1].dividers;
-                    for (let m1d of m1) {
-                        for (let m2d of m2) {
-                            // if(m1d.degree()===m2d.degree()){continue}
-                            let dividerPolynom = new Polynom(), result;
-                            dividerPolynom.monoms = [m1d.clone(), m2d.clone()];
-                            result = P.euclidian(dividerPolynom);
-                            if (result.reminder.isZero()) {
-                                P = result.quotient.clone();
-                                factors.push(dividerPolynom);
-                                continue;
-                            }
-                            dividerPolynom.monoms = [m1d.clone(), m2d.clone().opposed()];
-                            result = P.euclidian(dividerPolynom);
-                            if (result.reminder.isZero()) {
-                                P = result.quotient.clone();
-                                factors.push(dividerPolynom);
-                            }
+                    // Create the list of all "potential" polynom dividers.
+                    let allDividers = this._getAllPotentialFactors(P, letter);
+                    allDividers.every(div => {
+                        result = P.euclidian(div);
+                        if (result.reminder.isZero()) {
+                            P = result.quotient.clone();
+                            factors.push(div);
+                            return false;
                         }
-                    }
+                        return true;
+                    });
                 }
             }
+            if (!P.isOne()) {
+                factors.push(P.clone());
+            }
             this.factors = factors;
             return factors;
         };
+        this._getAllPotentialFactors = (P, letter) => {
+            let m1 = P.monoms[0].dividers, m2 = P.monoms[P.monoms.length - 1].dividers;
+            let allDividers = [];
+            m1.forEach(m1d => {
+                m2.forEach(m2d => {
+                    if (m1d.degree(letter).isNotEqual(m2d.degree(letter))) {
+                        allDividers.push(new Polynom(m1d, m2d));
+                        allDividers.push(new Polynom(m1d, m2d.clone().opposed()));
+                    }
+                });
+            });
+            return allDividers;
+        };
         // TODO: get zeroes for more than first degree and for more than natural degrees
         this.getZeroes = () => {
-            const Z = [];
-            switch (this.degree().value) {
-                case 0:
-                    if (this._monoms[0].coefficient.value === 0) {
-                        return [true];
-                    }
-                    else {
-                        return [false];
-                    }
-                case 1:
-                    // There is only one monoms,
-                    if (this._monoms.length === 1) {
-                        return [new fraction_1.Fraction().zero()];
-                    }
-                    else {
-                        const P = this.clone().reduce().reorder();
-                        return [P.monoms[1].coefficient.opposed().divide(P.monoms[0].coefficient)];
-                    }
-                // TODO: Determine the zeros of an equation of second degree.
-                //case 2:
-                default:
-                    // Make sure the polynom is factorized.
-                    if (this._factors.length === 0) {
-                        this.factorize();
-                    }
-                    let zeroes = [], zeroesAsTex = [];
-                    for (let P of this._factors) {
-                        if (P.degree().greater(2)) {
-                            // TODO: Handle other polynom.
-                        }
-                        else if (P.degree().value === 2) {
-                            let A = P.monomByDegree(2).coefficient, B = P.monomByDegree(1).coefficient, C = P.monomByDegree(0).coefficient, D = B.clone().pow(2).subtract(A.clone().multiply(C).multiply(4));
-                            if (D.value > 0) {
-                                /*console.log('Two zeroes for ', P.tex); */
-                                let x1 = (-(B.value) + Math.sqrt(D.value)) / (2 * A.value), x2 = (-(B.value) - Math.sqrt(D.value)) / (2 * A.value);
-                                zeroes.push(new fraction_1.Fraction(x1.toFixed(3)).reduce());
-                                zeroes.push(new fraction_1.Fraction(x2.toFixed(3)).reduce());
-                            }
-                            else if (D.value === 0) {
-                                /*console.log('One zero for ', P.tex); */
-                            }
-                            else {
-                                console.log('No zero for ', P.tex);
-                            }
-                        }
-                        else {
-                            for (let z of P.getZeroes()) {
-                                // Check if the zero is already in the list.
-                                if (z === false || z === true) {
-                                    continue;
-                                }
-                                if (zeroesAsTex.indexOf(z.frac) === -1) {
-                                    zeroes.push(z);
-                                    zeroesAsTex.push(z.frac);
-                                }
-                            }
-                        }
-                    }
-                    return zeroes;
-            }
-            return Z;
+            let equ = new equation_1.Equation(this.clone(), 0);
+            equ.solve();
+            return equ.solutions;
+            //
+            // const Z: Fraction[] = [];
+            //
+            // // ISolution: {tex: string, value: number, exact: boolean|Fraction|...}
+            //
+            // switch (this.degree().value) {
+            //     case 0:
+            //         if (this._monoms[0].coefficient.value === 0) {
+            //             return [{
+            //                 tex: '\\mathbb{R}',
+            //                 value: NaN,
+            //                 exact: false
+            //             }];
+            //         } else {
+            //             return [{
+            //                 tex: '\\varnothing',
+            //                 value: NaN,
+            //                 exact: false
+            //             }];
+            //         }
+            //     case 1:
+            //         // There is only one monoms,
+            //         if (this._monoms.length === 1) {
+            //             return [{
+            //                 tex: '0',
+            //                 value: 0,
+            //                 exact: new Fraction().zero()
+            //             }];
+            //         } else {
+            //             const P = this.clone().reduce().reorder();
+            //             const coeff = P.monoms[1].coefficient.opposed().divide(P.monoms[0].coefficient)
+            //             return [{
+            //                 tex: coeff.tex,
+            //                 value: coeff.value,
+            //                 exact: coeff
+            //             }];
+            //         }
+            //     // TODO: Determine the zeros of an equation of second degree.
+            //     //case 2:
+            //     default:
+            //         // Make sure the polynom is factorized.
+            //         if (this._factors.length === 0) {
+            //             this.factorize()
+            //         }
+            //
+            //         let zeroes:Fraction[] = [], zeroesAsTex = [];
+            //         for (let P of this._factors) {
+            //             if (P.degree().greater(2)) {
+            //                 // TODO: get zeroes of polynom with a degree greater than 2.
+            //
+            //             } else if (P.degree().value === 2) {
+            //                 let A = P.monomByDegree(2).coefficient,
+            //                     B = P.monomByDegree(1).coefficient,
+            //                     C = P.monomByDegree(0).coefficient,
+            //                     D = B.clone().pow(2).subtract(A.clone().multiply(C).multiply(4));
+            //
+            //                 if (D.value > 0) {
+            //                     /*console.log('Two zeroes for ', P.tex); */
+            //                     let x1 = (-(B.value) + Math.sqrt(D.value)) / (2 * A.value),
+            //                         x2 = (-(B.value) - Math.sqrt(D.value)) / (2 * A.value);
+            //
+            //                     zeroes.push(new Fraction(x1.toFixed(3)).reduce());
+            //                     zeroes.push(new Fraction(x2.toFixed(3)).reduce());
+            //                 } else if (D.value === 0) {
+            //                     /*console.log('One zero for ', P.tex); */
+            //                 } else {
+            //                     console.log('No zero for ', P.tex);
+            //                 }
+            //             } else {
+            //                 for (let z of P.getZeroes()) {
+            //                     // Check if the zero is already in the list.
+            //                     // if (z === false || z === true) {
+            //                     //     continue;
+            //                     // }
+            //                     if (zeroesAsTex.indexOf(z.frac) === -1) {
+            //                         zeroes.push(z);
+            //                         zeroesAsTex.push(z.frac);
+            //                     }
+            //                 }
+            //             }
+            //         }
+            //
+            //
+            //         return zeroes;
+            // }
+            // return Z;
         };
         // TODO: analyse the next functions to determine if they are useful or not...
         this.monomByDegree = (degree, letter) => {
@@ -2736,6 +2830,28 @@ class Polynom {
             }
             return M;
         };
+        this.limitToInfinity = (letter) => {
+            const M = this.monomByDegree(undefined, letter), sign = M.coefficient.sign(), degree = M.degree(letter);
+            if (degree.isStrictlyPositive()) {
+                return sign === 1 ? (new fraction_1.Fraction()).infinite() : (new fraction_1.Fraction()).infinite().opposed();
+            }
+            else if (degree.isZero()) {
+                return M.coefficient;
+            }
+            // Any other cases
+            return (new fraction_1.Fraction()).zero();
+        };
+        this.limitToNegativeInfinity = (letter) => {
+            const M = this.monomByDegree(undefined, letter), sign = M.coefficient.sign(), degree = M.degree(letter);
+            if (degree.isStrictlyPositive()) {
+                return sign === -1 ? (new fraction_1.Fraction()).infinite() : (new fraction_1.Fraction()).infinite().opposed();
+            }
+            else if (degree.isZero()) {
+                return M.coefficient;
+            }
+            // Any other cases
+            return (new fraction_1.Fraction()).zero();
+        };
         this.genDisplay = (output, forceSign, wrapParentheses) => {
             let P = '';
             for (const k of this._monoms) {
@@ -2993,6 +3109,9 @@ class Polynom {
     }
     get texFactors() {
         this.factorize();
+        if (this.factors.length === 0) {
+            return this.tex;
+        }
         let tex = '';
         for (let f of this.factors) {
             if (f.monoms.length > 1) {
@@ -3172,13 +3291,13 @@ Polynom.addToken = (stack, element) => {
             break;
     }
 };
-
-
-/***/ }),
-
-/***/ 107:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 107:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 /**
  * Rational polynom module contains everything necessary to handle rational polynoms.
@@ -3188,6 +3307,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Rational = void 0;
 const polynom_1 = __webpack_require__(38);
 const fraction_1 = __webpack_require__(506);
+const equation_1 = __webpack_require__(760);
 /**
  * Rational class can handle rational polynoms
  */
@@ -3205,18 +3325,15 @@ class Rational {
         };
         this.domain = () => {
             let zeroes = this._denominator.getZeroes();
-            if (zeroes.length === 0 || zeroes[0] === false) {
-                return '\\mathbb{R}';
+            if (zeroes.length === 0 || zeroes[0].tex === equation_1.PARTICULAR_SOLUTION.real) {
+                return equation_1.PARTICULAR_SOLUTION.real;
             }
-            else if (zeroes[0] === true) {
-                return '\\varnothing';
+            else if (zeroes[0].tex === equation_1.PARTICULAR_SOLUTION.varnothing) {
+                return equation_1.PARTICULAR_SOLUTION.varnothing;
             }
             else {
-                return '\\mathbb{R}\\setminus\\left{' +
-                    zeroes.map(x => {
-                        return (typeof x === 'boolean') ? '' : x.frac;
-                    })
-                        .join(';') + '\\right}';
+                return '\\mathbb{R}\\setminus\\left\\{' +
+                    zeroes.map(x => x.tex).join(';') + '\\right\\}';
             }
         };
         this.amplify = (P) => {
@@ -3224,6 +3341,12 @@ class Rational {
             this._denominator.multiply(P);
             return this;
         };
+        this.derivative = (letter) => {
+            let N = this._numerator.clone(), D = this._denominator.clone(), dN = N.clone().derivative(letter), dD = D.clone().derivative(letter);
+            this._numerator = dN.clone().multiply(D).subtract(N.clone().multiply(dD));
+            this._denominator = D.clone().pow(2);
+            return this;
+        };
         this.simplify = (P) => {
             let NumeratorEuclidien = this._numerator.euclidian(P);
             if (!NumeratorEuclidien.reminder.isZero()) {
@@ -3238,9 +3361,7 @@ class Rational {
             return this;
         };
         this.reduce = () => {
-            console.log(this._numerator.tex);
             this._numerator.factorize();
-            console.log(this._numerator.factors.map(x => x.tex));
             for (let f of this._numerator.factors) {
                 this.simplify(f);
             }
@@ -3265,50 +3386,157 @@ class Rational {
         this.subtract = (R) => {
             return this.add(R.clone().opposed());
         };
-        this.limits = (value, letter) => {
+        this.limits = (value, offset, letter) => {
             if (value === Infinity || value === -Infinity) {
-                let N = this._numerator.monomByDegree(this._numerator.degree(letter), letter), D = this._denominator.monomByDegree(this._denominator.degree(letter), letter);
-                N.divide(D);
-                if (N.degree(letter).isStrictlyPositive()) {
-                    return N.coefficient.sign() * (Math.pow((value > 0 ? 1 : -1), N.degree(letter).value % 2)) === 1 ? Infinity : -Infinity;
-                }
-                if (N.degree(letter).isZero()) {
-                    return N.coefficient;
+                let { quotient, reminder } = this._numerator.clone().euclidian(this._denominator);
+                // quotient is positive => it will be infinite.
+                if (quotient.degree(letter).isStrictlyPositive()) {
+                    return value === Infinity ? quotient.limitToInfinity(letter) : quotient.limitToNegativeInfinity(letter);
+                    // return quotient.monomByDegree(undefined, letter).coefficient.sign()===1?(new Fraction()).infinite():(new Fraction()).infinite().opposed()
                 }
-                if (N.degree(letter).isStrictlyPositive()) {
-                    return N.coefficient.sign() * (Math.pow(-1, N.degree(letter).value % 2)) === 1 ? 0 : -0;
+                else {
+                    return quotient.monomByDegree(undefined, letter).coefficient;
                 }
             }
             else {
-                return this._numerator.evaluate({ letter: new fraction_1.Fraction(value) }).divide(this._denominator.evaluate({ letter: new fraction_1.Fraction(value) }));
+                let evalValues = {}, evalValuesOffset = {}, theLimit, theSign, FR = this.clone().reduce();
+                evalValues[letter === undefined ? 'x' : letter] = new fraction_1.Fraction(value);
+                if (offset !== 'above' && offset !== 'below') {
+                    theLimit = FR._numerator.evaluate(evalValues)
+                        .divide(FR._denominator.evaluate(evalValues));
+                    return theLimit.isInfinity() ? theLimit.abs() : theLimit;
+                }
+                else {
+                    if (offset === 'above') {
+                        evalValuesOffset[letter === undefined ? 'x' : letter] = (new fraction_1.Fraction(value)).add(0.000001);
+                    }
+                    else if (offset === 'below') {
+                        evalValuesOffset[letter === undefined ? 'x' : letter] = (new fraction_1.Fraction(value)).subtract(0.000001);
+                    }
+                    theLimit = FR._numerator.evaluate(evalValues)
+                        .divide(FR._denominator.evaluate(evalValues));
+                    theSign = FR._numerator.evaluate(evalValuesOffset)
+                        .divide(FR._denominator.evaluate(evalValuesOffset)).sign();
+                    if (theLimit.isInfinity()) {
+                        return theSign === 1 ? theLimit.abs() : theLimit.abs().opposed();
+                    }
+                    else {
+                        return theLimit;
+                    }
+                }
+            }
+        };
+        this.makeTableOfSigns = () => {
+            // Factorize the numerator and the denominator
+            this._numerator.factorize();
+            this._denominator.factorize();
+            let zeroes = equation_1.Equation.makeSolutionsUnique([...this._numerator.getZeroes(), ...this._denominator.getZeroes()], true), NFactors = this._numerator.factors, DFactors = this._denominator.factors;
+            let tableOfSigns = [], result = [];
+            NFactors.forEach(factor => {
+                tableOfSigns.push(this._makeOneLineOfTableOfSigns(factor, zeroes, 'z'));
+            });
+            DFactors.forEach(factor => {
+                tableOfSigns.push(this._makeOneLineOfTableOfSigns(factor, zeroes, 'd'));
+            });
+            // Empty line
+            tableOfSigns.push([]);
+            // Add the final row as cumulative
+            let resultLine = tableOfSigns[0].map((x, index) => {
+                if (index === 0) {
+                    return '';
+                }
+                if (index === tableOfSigns[0].length - 1) {
+                    return '';
+                }
+                if (index % 2 === 0) {
+                    return 't';
+                }
+                return '+';
+            });
+            for (let current of tableOfSigns) {
+                for (let i = 0; i < current.length; i++) {
+                    if (i % 2 === 0) {
+                        // t, z or d
+                        if (resultLine[i] === 'd') {
+                            continue;
+                        }
+                        if (current[i] !== 't') {
+                            resultLine[i] = current[i];
+                        }
+                    }
+                    else {
+                        // + or -
+                        if (current[i] === '-') {
+                            resultLine[i] = resultLine[i] === '+' ? '-' : '+';
+                        }
+                    }
+                }
             }
+            // Add the variation line.
+            // TODO: add the variation line.
+            tableOfSigns.push(resultLine);
+            let tos = {
+                factors: [...NFactors, ...DFactors],
+                zeroes: zeroes,
+                signs: tableOfSigns,
+                tex: ''
+            };
+            this._makeTexFromTableOfSigns(tos);
+            return tos;
+        };
+        this._makeTexFromTableOfSigns = (tos) => {
+            let tex = `\\begin{tikzpicture}
+\\tkzTabInit[lgt=3,espcl=2,deltacl=0]{/1.2,\\(${tos.factors.map(x => x.tex).join('\\)/1,\\(')}\\)/1,/.1,\\(f(x)\\)/1.2}{{\\scriptsize \\hspace{1cm} \\(-\\infty\\)},\\(${tos.zeroes.map(x => x.tex).join('\\),\\(')}\\),{\\scriptsize \\hspace{-1cm} \\(+\\infty\\)}}`;
+            tos.signs.forEach(list => {
+                tex += (`\n\\tkzTabLine{${list.join(',')}}`);
+            });
+            tex += `\n\\end{tikzpicture}`;
+            tos.tex = tex;
+            return tex;
+        };
+        this._makeOneLineOfTableOfSigns = (factor, zeroes, zeroSign) => {
+            let oneLine = [], currentZero = factor.getZeroes().map(x => x.tex);
+            // First +/- sign, before the first zero
+            oneLine.push('');
+            oneLine.push(factor.evaluate(zeroes[0].value - 1).sign() === 1 ? '+' : '-');
+            for (let i = 0; i < zeroes.length; i++) {
+                // Add the zero if it's the current one
+                oneLine.push(currentZero.includes(zeroes[i].tex) ? zeroSign : 't');
+                // + / - sign after the current zero
+                if (i < zeroes.length - 1) {
+                    oneLine.push(factor.evaluate((zeroes[i].value + zeroes[i + 1].value) / 2).sign() === 1 ? '+' : '-');
+                }
+                else if (i === zeroes.length - 1) {
+                    oneLine.push(factor.evaluate(zeroes[i].value + 1).sign() === 1 ? '+' : '-');
+                }
+            }
+            oneLine.push('');
+            return oneLine;
         };
         this._numerator = numerator ? numerator.clone() : new polynom_1.Polynom();
         this._denominator = denominator ? denominator.clone() : new polynom_1.Polynom();
     }
-    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;
     }
+    get tex() {
+        return `\\frac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
+    }
+    get texFactors() {
+        return `\\frac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`;
+    }
 }
 exports.Rational = Rational;
-
-
-/***/ }),
-
-/***/ 506:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 506:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Fraction = void 0;
@@ -3639,10 +3867,10 @@ class Fraction {
             return isNaN(this._numerator);
         };
         this.isInfinity = () => {
-            return this._numerator === Infinity;
+            return Math.abs(this._numerator) === Infinity;
         };
         this.isFinite = () => {
-            return !this.isInfinity();
+            return !this.isInfinity() && !this.isNaN();
         };
         this.isSquare = () => {
             return Math.sqrt(this._numerator) % 1 === 0 && Math.sqrt(this._denominator) % 1 === 0;
@@ -3687,9 +3915,6 @@ class Fraction {
         }
         return this;
     }
-    get isFraction() {
-        return true;
-    }
     // ------------------------------------------
     // Getter and setter
     // ------------------------------------------
@@ -3710,6 +3935,9 @@ class Fraction {
     }
     // Display getter
     get tex() {
+        if (this.isInfinity()) {
+            return `${this.sign() === 1 ? '+' : '-'}\\infty`;
+        }
         if (this._denominator === 1) {
             return `${this._numerator}`;
         }
@@ -3760,20 +3988,52 @@ Fraction.min = (...fractions) => {
     }
     return M;
 };
-
-
-/***/ }),
-
-/***/ 923:
-/***/ ((__unused_webpack_module, exports) => {
-
+Fraction.average = (...fractions) => {
+    let M = new Fraction().zero();
+    for (let f of fractions) {
+        M.add(f);
+    }
+    M.divide(fractions.length);
+    return M;
+};
+Fraction.unique = (fractions, sorted) => {
+    // TODO: make sure it's wokring -> test !
+    let unique = {}, distinct = [];
+    fractions.forEach(x => {
+        if (!unique[x.clone().reduce().tex]) {
+            distinct.push(x.clone());
+            unique[x.tex] = true;
+        }
+    });
+    if (sorted) {
+        return Fraction.sort(distinct);
+    }
+    else {
+        return distinct;
+    }
+};
+Fraction.sort = (fractions, reverse) => {
+    // Todo make sure it's the correct order, not reverse -> make a test
+    let sorted = fractions.sort((a, b) => a.value - b.value);
+    if (reverse) {
+        sorted.reverse();
+    }
+    return sorted;
+};
+
+
+/***/ }),
+
+/***/ 872:
+/***/ ((__unused_webpack_module, exports) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Nthroot = void 0;
+exports.NthRoot = void 0;
 /**
- * Nthroot is something like "a+b\sqrt{3}
+ * NthRoot is something like "a+b\sqrt{3}
  */
-class Nthroot {
+class NthRoot {
     constructor(...values) {
         // ------------------------------------------
         // Creation / parsing functions
@@ -3879,14 +4139,14 @@ class Nthroot {
         return this._coefficient * Math.pow(this._radical, 1 / this._nth);
     }
 }
-exports.Nthroot = Nthroot;
-
-
-/***/ }),
-
-/***/ 735:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+exports.NthRoot = NthRoot;
+
+
+/***/ }),
+
+/***/ 735:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.NumExp = void 0;
@@ -4041,13 +4301,13 @@ class NumExp {
     }
 }
 exports.NumExp = NumExp;
-
-
-/***/ }),
-
-/***/ 75:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 75:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.PolynomExpProduct = exports.PolynomExpFactor = void 0;
@@ -4206,7 +4466,7 @@ class PolynomExpProduct {
                 }
                 // restore all degrees to negative again.
                 denominators.map(x => x.degree.opposed());
-                tex = `\\dfrac{ ${numeratorsAsTex.join(' \\cdot ')} }{ ${denominatorsAsTex.join(' \\cdot ')} }`;
+                tex = `\\frac{ ${numeratorsAsTex.join(' \\cdot ')} }{ ${denominatorsAsTex.join(' \\cdot ')} }`;
             }
         }
         // Apply the modification
@@ -4293,13 +4553,13 @@ class PolynomExpProduct {
     }
 }
 exports.PolynomExpProduct = PolynomExpProduct;
-
-
-/***/ }),
-
-/***/ 699:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 699:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Circle = void 0;
@@ -4606,13 +4866,13 @@ class Circle {
     }
 }
 exports.Circle = Circle;
-
-
-/***/ }),
-
-/***/ 9:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 9:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 /**
  * This class works for 2d line in a plane.
@@ -4696,6 +4956,14 @@ class Line {
                         return this.parseByPointAndVector(values[0], values[1]);
                     }
                 }
+                else if (values[0] instanceof point_1.Point && values[1] instanceof Line) {
+                    if (values[2] === LinePropriety.Parallel || values[2] === null) {
+                        return this.parseByPointAndLine(values[0], values[1], LinePropriety.Parallel);
+                    }
+                    else {
+                        return this.parseByPointAndLine(values[0], values[1], LinePropriety.Perpendicular);
+                    }
+                }
             }
             // TODO: Add the ability to create line from a normal vector
             console.log('Someting wrong happend while creating the line');
@@ -5009,13 +5277,13 @@ class Line {
 exports.Line = Line;
 Line.PERPENDICULAR = LinePropriety.Perpendicular;
 Line.PARALLEL = LinePropriety.Parallel;
-
-
-/***/ }),
-
-/***/ 557:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 557:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Point = void 0;
@@ -5114,7 +5382,7 @@ class Point {
                 let V = new vector_1.Vector(this, item);
                 value = V.norm;
                 fraction = V.normSquare.sqrt();
-                tex = V.normSquare.isSquare() ? fraction.tex : `\\sqrt{\\dfrac{ ${V.normSquare.numerator} }{ ${V.normSquare.denominator} }}`;
+                tex = V.normSquare.isSquare() ? fraction.tex : `\\sqrt{\\frac{ ${V.normSquare.numerator} }{ ${V.normSquare.denominator} }}`;
             }
             return { value, fraction, tex };
         };
@@ -5179,13 +5447,13 @@ Point.pmatrix = (a, b, c) => {
         return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\\\ ${c.tex ? c.tex : c} \\end{pmatrix}`;
     }
 };
-
-
-/***/ }),
-
-/***/ 164:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 164:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Triangle = void 0;
@@ -5454,13 +5722,13 @@ class Triangle {
     }
 }
 exports.Triangle = Triangle;
-
-
-/***/ }),
-
-/***/ 586:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 586:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Vector = void 0;
@@ -5638,13 +5906,13 @@ Vector.scalarProduct = (v1, v2) => {
     // TODO: Transform to fraction with nthroot.
     return v1.x.value * v2.x.value + v1.y.value * v2.y.value;
 };
-
-
-/***/ }),
-
-/***/ 956:
-/***/ ((__unused_webpack_module, exports) => {
-
+
+
+/***/ }),
+
+/***/ 956:
+/***/ ((__unused_webpack_module, exports) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Numeric = void 0;
@@ -5750,13 +6018,13 @@ class Numeric {
     }
 }
 exports.Numeric = Numeric;
-
-
-/***/ }),
-
-/***/ 330:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
+
+
+/***/ }),
+
+/***/ 330:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
 
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -5818,13 +6086,13 @@ var Random;
     }
     Random.shuffle = shuffle;
 })(Random = exports.Random || (exports.Random = {}));
-
-
-/***/ }),
-
-/***/ 373:
-/***/ ((__unused_webpack_module, exports) => {
-
+
+
+/***/ }),
+
+/***/ 373:
+/***/ ((__unused_webpack_module, exports) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.randomCore = void 0;
@@ -5846,13 +6114,13 @@ class randomCore {
     }
 }
 exports.randomCore = randomCore;
-
-
-/***/ }),
-
-/***/ 754:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 754:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.rndFraction = void 0;
@@ -5892,13 +6160,13 @@ class rndFraction extends randomCore_1.randomCore {
     }
 }
 exports.rndFraction = rndFraction;
-
-
-/***/ }),
-
-/***/ 140:
-/***/ ((__unused_webpack_module, exports) => {
-
+
+
+/***/ }),
+
+/***/ 140:
+/***/ ((__unused_webpack_module, exports) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.rndHelpers = void 0;
@@ -5967,13 +6235,13 @@ class rndHelpers {
     }
 }
 exports.rndHelpers = rndHelpers;
-
-
-/***/ }),
-
-/***/ 793:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 793:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.rndMonom = void 0;
@@ -6026,13 +6294,13 @@ class rndMonom extends randomCore_1.randomCore {
     }
 }
 exports.rndMonom = rndMonom;
-
-
-/***/ }),
-
-/***/ 22:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
+
+
+/***/ }),
+
+/***/ 22:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.rndPolynom = void 0;
@@ -6107,22 +6375,22 @@ class rndPolynom extends randomCore_1.randomCore {
     }
 }
 exports.rndPolynom = rndPolynom;
-
-
-/***/ }),
-
-/***/ 230:
-/***/ ((__unused_webpack_module, exports) => {
-
+
+
+/***/ }),
+
+/***/ 230:
+/***/ ((__unused_webpack_module, exports) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-
-
-/***/ }),
-
-/***/ 505:
-/***/ ((__unused_webpack_module, exports) => {
-
+
+
+/***/ }),
+
+/***/ 505:
+/***/ ((__unused_webpack_module, exports) => {
+
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Shutingyard = exports.ShutingyardMode = exports.ShutingyardType = exports.tokenConstant = void 0;
@@ -6427,43 +6695,43 @@ class Shutingyard {
     }
 }
 exports.Shutingyard = Shutingyard;
-
-
-/***/ })
-
-/******/ 	});
-/************************************************************************/
-/******/ 	// The module cache
-/******/ 	var __webpack_module_cache__ = {};
-/******/ 	
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/ 		// Check if module is in cache
-/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
-/******/ 		if (cachedModule !== undefined) {
-/******/ 			return cachedModule.exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = __webpack_module_cache__[moduleId] = {
-/******/ 			// no module.id needed
-/******/ 			// no module.loaded needed
-/******/ 			exports: {}
-/******/ 		};
-/******/ 	
-/******/ 		// Execute the module function
-/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/ 	
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/ 	
-/************************************************************************/
-/******/ 	
-/******/ 	// startup
-/******/ 	// Load entry module and return exports
-/******/ 	// This entry module is referenced by other modules so it can't be inlined
-/******/ 	var __webpack_exports__ = __webpack_require__(607);
-/******/ 	
-/******/ })()
-;
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(607);
+/******/ 	
+/******/ })()
+;
 //# sourceMappingURL=pi.js.map