pimath 0.0.60 → 0.0.63

package/dist/pi.js

@@ -932,7 +932,6 @@ class LinearSystem {
         this.log = () => {
             let str = '';
             for (let E of this._equations) {
-                console.log(E.tex);
                 str += `${E.tex}\\n}`;
             }
             return str;
@@ -1673,6 +1672,9 @@ class Monom {
                 return this.evaluate(tmpValues);
             }
             if (typeof values === 'object') {
+                if (this.variables.length === 0) {
+                    return this.coefficient;
+                }
                 for (let L in this._literal) {
                     if (values[L] === undefined) {
                         return new fraction_1.Fraction().zero();
@@ -1760,6 +1762,21 @@ class Monom {
             // All checks passed.
             return true;
         };
+        this.isDivisible = (div) => {
+            // For all variables (letters), the current monom must have a degree higher than the divider
+            if (div.degree().isStrictlyPositive()) {
+                for (let letter of div.variables) {
+                    if (!this.degree(letter).geq(div.degree(letter))) {
+                        return false;
+                    }
+                }
+            }
+            // If the coefficient is rational, we suppose we don't need to check the division by the coefficient.
+            if (this.coefficient.isRational() || div.coefficient.isRational()) {
+                return true;
+            }
+            return this.coefficient.clone().divide(div.coefficient).isRelative();
+        };
         this.zero();
         if (value !== undefined) {
             // A string is given - try to parse the value.
@@ -2135,6 +2152,11 @@ class Polynom {
      * @param values
      */
     constructor(polynomString, ...values) {
+        this.mark_as_dirty = () => {
+            this.dirty_factors = true;
+            this.dirty_zeroes = true;
+            this.euclidianCache = {};
+        };
         this.addToken = (stack, element) => {
             switch (element.tokenType) {
                 case shutingyard_1.ShutingyardType.COEFFICIENT:
@@ -2222,6 +2244,7 @@ class Polynom {
             // Reset the main variables.
             this._monoms = [];
             this._factors = [];
+            this.mark_as_dirty();
             if (typeof inputStr === 'string') {
                 return this._parseString(inputStr, ...values);
             }
@@ -2262,88 +2285,32 @@ class Polynom {
             this._monoms = [];
             this._monoms.push(new monom_1.Monom().zero());
             this._rawString = '0';
+            this.mark_as_dirty();
             return this;
         };
         this.one = () => {
             this._monoms = [];
             this._monoms.push(new monom_1.Monom().one());
             this._rawString = '1';
+            this.mark_as_dirty();
             return this;
         };
         this.empty = () => {
             this._monoms = [];
             this._rawString = '';
+            this.mark_as_dirty();
             return this;
         };
         // ------------------------------------------
         this.opposed = () => {
             this._monoms = this._monoms.map(m => m.opposed());
+            this.mark_as_dirty();
             return this;
         };
-        // // -----------------------------------------------
-        // // Polynom generators and randomizers
-        // // -----------------------------------------------
-        // random(config?: randomPolynomConfig) {
-        //     return Random.polynom(config);
-        // }
-        //
-        // private _randomizeDefaults: { [key: string]: number | string | boolean } = {
-        //     degree: 2,
-        //     unit: true,
-        //     fractions: false,
-        //     factorable: false,
-        //     letters: 'x',
-        //     allowNullMonom: false,
-        //     numberOfMonoms: false
-        // };
-        // get randomizeDefaults(): { [key: string]: number | string | boolean } {
-        //     return this._randomizeDefaults;
-        // }
-        //
-        // set randomizeDefaults(value) {
-        //     this._randomizeDefaults = value;
-        // }
-        //
-        // randomize = (config: { [key: string]: number | string | boolean }): Polynom => {
-        //     let P = new Polynom();
-        //
-        //     // Check the config file and use the default values.
-        //     if (config === undefined) {
-        //         config = {};
-        //     }
-        //     for (let k in this._randomizeDefaults) {
-        //         if (config[k] === undefined) {
-        //             config[k] = this._randomizeDefaults[k];
-        //         }
-        //     }
-        //
-        //     // TODO: Build a more robust randomize function
-        //     return P;
-        // }
-        //
-        // rndFactorable = (degree: number = 2, unit: boolean | number = false, letters: string = 'x'): Polynom => {
-        //     // TODO: Make rndFactorable polynom generator more user friendly
-        //     this._factors = [];
-        //     for (let i = 0; i < degree; i++) {
-        //         let factorUnit = unit === true || i >= unit,
-        //             p = Random.polynom({
-        //                 degree: 1,
-        //                 unit: factorUnit,
-        //                 fraction: false,
-        //                 letters
-        //             });
-        //         this._factors.push(p);
-        //     }
-        //
-        //     this.empty().monoms = this._factors[0].monoms;
-        //     for (let i = 1; i < this._factors.length; i++) {
-        //         this.multiply(this._factors[i]);
-        //     }
-        //     return this;
-        // };
         // ------------------------------------------
         // Mathematical operations
         this.add = (...values) => {
+            this.mark_as_dirty();
             for (let value of values) {
                 if (value instanceof Polynom) {
                     this._monoms = this._monoms.concat(value.monoms);
@@ -2361,6 +2328,7 @@ class Polynom {
             return this.reduce();
         };
         this.subtract = (...values) => {
+            this.mark_as_dirty();
             for (let value of values) {
                 if (value instanceof Polynom) {
                     this._monoms = this._monoms.concat(value.clone().opposed().monoms);
@@ -2378,6 +2346,7 @@ class Polynom {
             return this.reduce();
         };
         this.multiply = (value) => {
+            this.mark_as_dirty();
             if (value instanceof Polynom) {
                 return this.multiplyByPolynom(value);
             }
@@ -2399,6 +2368,9 @@ class Polynom {
          * returns {quotient: Polynom, reminder: Polynom}
          */
         this.euclidian = (P) => {
+            if (this.euclidianCache[P.tex] !== undefined) {
+                return this.euclidianCache[P.tex];
+            }
             const letter = P.variables[0];
             const quotient = new Polynom().zero();
             const reminder = this.clone().reorder(letter);
@@ -2432,6 +2404,7 @@ class Polynom {
             return { quotient, reminder };
         };
         this.divide = (value) => {
+            this.mark_as_dirty();
             if (value instanceof fraction_1.Fraction) {
                 return this.divideByFraction(value);
             }
@@ -2445,6 +2418,7 @@ class Polynom {
             }
         };
         this.pow = (nb) => {
+            this.mark_as_dirty();
             if (!Number.isSafeInteger(nb)) {
                 return this.zero();
             }
@@ -2645,6 +2619,7 @@ class Polynom {
          * @param P
          */
         this.replaceBy = (letter, P) => {
+            this.mark_as_dirty();
             let pow;
             const resultPolynom = new Polynom().zero();
             for (const m of this.monoms) {
@@ -2704,146 +2679,108 @@ class Polynom {
          * @param maxValue Defines the greatest value to search to (default is 20).
          */
         this.factorize = (letter) => {
-            let factors = [];
-            // Extract the common monom
-            let P = this.clone().reorder(), M = P.commonMonom(), tempPolynom;
-            // It has a common monom.
-            if (!M.isOne()) {
-                tempPolynom = new Polynom(M);
-                factors = [tempPolynom.clone()];
-                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()) {
+            if (this.dirty_factors) {
+                let factors = [];
+                let P = this.clone().reorder();
+                // Extract the common monom
+                // 2x^3+6x^2 => 2x^2
+                let M = P.commonMonom();
+                if (!M.isOne()) {
+                    let tempPolynom = new Polynom(M);
+                    factors = [tempPolynom.clone()];
+                    P = P.euclidian(tempPolynom).quotient;
+                }
+                // Main loop
+                let securityLoop = P.degree().clone().multiply(2).value, maxDegree = 1;
+                while (securityLoop >= 0) {
+                    securityLoop--;
+                    if (P.monoms.length < 2) {
+                        // The polynom has only one monom => 7x^2
+                        // No need to continue.
+                        if (!P.isOne()) {
+                            factors.push(P.clone());
+                            P.one();
+                        }
+                        break;
+                    }
+                    else if (P.degree(letter).isOne()) {
+                        // The polynom is a first degree polynom => 3x-5
+                        // No need to continue
                         factors.push(P.clone());
                         P.one();
+                        break;
+                    }
+                    else {
+                        // Create the list of all "potential" polynom dividers.
+                        let allDividers = this._getAllPotentialFactors(P, maxDegree, letter);
+                        maxDegree = P.degree(letter).value;
+                        // Actually: 100ms
+                        while (allDividers.length > 0) {
+                            let div = allDividers[0];
+                            if (!P.isDividableBy(div)) {
+                                // Not dividable. Remove it from the list
+                                allDividers.shift();
+                            }
+                            else {
+                                // It's dividable - so make the division
+                                let result = P.euclidian(div);
+                                // Add the factor
+                                factors.push(div);
+                                // As it's dividable, get the quotient.
+                                P = result.quotient.clone();
+                                // filter all dividers that are no more suitable.
+                                allDividers = allDividers.filter(x => {
+                                    let pX = P.monoms[0], pC = P.monoms[P.monoms.length - 1], dX = x.monoms[0], dC = x.monoms[x.monoms.length - 1];
+                                    // Check last item (degree zero)
+                                    if (!pC.isDivisible(dC)) {
+                                        return false;
+                                    }
+                                    // Check the first item (degree max)
+                                    if (!pX.isDivisible(dX)) {
+                                        return false;
+                                    }
+                                    return true;
+                                });
+                            }
+                        }
                     }
-                    break;
                 }
-                else if (P.degree(letter).isOne()) {
+                // Maybe there is still something in the Polynom (not everything was possible to factorize)
+                if (!P.isOne()) {
                     factors.push(P.clone());
-                    P.one();
-                    break;
+                }
+                // Save the factors
+                this._factors = factors;
+                // The factors list is no more dirty
+                this.dirty_factors = false;
+            }
+            return this._factors;
+        };
+        this.isDividableBy = (div) => {
+            // Quick evaluation.
+            if (div.degree().isOne()) {
+                let zero = div.getZeroes()[0];
+                if (zero.exact instanceof fraction_1.Fraction) {
+                    return this.evaluate(zero.exact).isZero();
                 }
                 else {
-                    // 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
-                    // 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;
-                    });
+                    return false;
                 }
             }
-            if (!P.isOne()) {
-                factors.push(P.clone());
+            else {
+                this.euclidianCache[div.tex] = this.euclidian(div);
+                return this.euclidianCache[div.tex].reminder.isZero();
             }
-            this.factors = factors;
-            return factors;
         };
         // TODO: get zeroes for more than first degree and for more than natural degrees
         this.getZeroes = () => {
-            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;
+            if (this.dirty_zeroes) {
+                let equ = new equation_1.Equation(this.clone(), 0);
+                equ.solve();
+                this._zeroes = equ.solutions;
+                this.dirty_zeroes = false;
+            }
+            return this._zeroes;
         };
         // TODO: analyse the next functions to determine if they are useful or not...
         this.monomByDegree = (degree, letter) => {
@@ -2958,16 +2895,19 @@ class Polynom {
             // Any other cases
             return (new fraction_1.Fraction()).zero();
         };
-        this._getAllPotentialFactors = (P, letter) => {
+        this._getAllPotentialFactors = (P, maxDegree, 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()));
-                    }
-                });
+                // Get only polynom that has a degree less than a specific value
+                if (m1d.degree(letter).leq(maxDegree)) {
+                    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;
         };
@@ -3019,41 +2959,6 @@ class Polynom {
                 this.add(stack[0]);
             }
             return this;
-            /**
-             let m1: Polynom;
-             let m2: Polynom;
-    
-             let stack: Polynom[] = [],
-             previousToken: string = null,
-             tempPolynom
-    
-             for (const element of rpn) {
-                if (element.tokenType === 'coefficient' || element.tokenType === 'variable') {
-                    tempPolynom = new Polynom().zero();
-                    tempPolynom.monoms = [new Monom(element.token)]
-                    stack.push(tempPolynom.clone())
-                } else if (element.tokenType === 'operation') {
-                    m2 = (stack.pop()) || new Polynom().zero();
-                    m1 = (stack.pop()) || new Polynom().zero();
-                    switch (element.token) {
-                        case '+':
-                            stack.push(m1.add(m2))
-                            break;
-                        case '-':
-                            stack.push(m1.subtract(m2))
-                            break;
-                        case '*':
-                            stack.push(m1.multiply(m2))
-                            break;
-                        case '^':
-                            stack.push(m1.pow(+previousToken))
-                    }
-                }
-                previousToken = element.token;
-            }
-    
-             this._monoms = stack[0].monoms;
-             return this;*/
         };
         this.multiplyByPolynom = (P) => {
             const M = [];
@@ -3178,33 +3083,6 @@ class Polynom {
                     }
                 }
                 return [this.clone()];
-                //
-                // console.log(a.tex, b.tex, c.tex)
-                // if (a.isSquare() && c.isSquare()) {
-                //     console.log('A C squares')
-                //     if (a.clone().sqrt().multiply(c.clone().sqrt()).multiplyByNumber(2).isSameAs(b)) {
-                //         console.log('HERE')
-                //         if (a.coefficient.sign() === b.coefficient.sign()) {
-                //             return []
-                //         }else{
-                //             return []
-                //         }
-                //     }
-                // } else if(a.isLiteralSquare() && c.isLiteralSquare()) {
-                //     console.log('A C litteral SQUARES')
-                //     // Check that the middle element is the product of a and c.
-                //
-                //     if(b.clone().pow(2).isSameAs(a.clone().multiply(c))){
-                //         console.log('SAME')
-                //
-                //     }else{
-                //         console.log('NOT SAME')
-                //     }
-                //
-                //     return [this.clone()]
-                // } else {
-                //     console.log('NOT SQUARES AT ALL !!!!')
-                // }
             }
         };
         this._factorizeByGroups = () => {
@@ -3213,11 +3091,31 @@ class Polynom {
         };
         this._monoms = [];
         this._factors = [];
+        this.mark_as_dirty();
         if (polynomString !== undefined) {
             this.parse(polynomString, ...values);
         }
         return this;
     }
+    get euclidianCache() {
+        return this._euclidianCache;
+    }
+    set euclidianCache(value) {
+        this._euclidianCache = value;
+    }
+    get dirty_zeroes() {
+        return this._dirty_zeroes;
+    }
+    set dirty_zeroes(value) {
+        this._dirty_zeroes = value;
+    }
+    // ------------------------------------------
+    get dirty_factors() {
+        return this._dirty_factors;
+    }
+    set dirty_factors(value) {
+        this._dirty_factors = value;
+    }
     // ------------------------------------------
     get monoms() {
         return this._monoms;
@@ -3225,10 +3123,14 @@ class Polynom {
     set monoms(M) {
         this._monoms = M;
     }
+    get zeroes() {
+        return this.getZeroes();
+    }
     get factors() {
-        return this._factors;
+        return this.factorize();
     }
     set factors(value) {
+        this.mark_as_dirty();
         this._factors = value;
     }
     get texString() {
@@ -3362,6 +3264,7 @@ exports.Rational = void 0;
 const polynom_1 = __webpack_require__(38);
 const fraction_1 = __webpack_require__(506);
 const equation_1 = __webpack_require__(760);
+const rationalStudy_1 = __webpack_require__(572);
 /**
  * Rational class can handle rational polynoms
  */
@@ -3373,9 +3276,7 @@ class Rational {
      */
     constructor(numerator, denominator) {
         this.clone = () => {
-            this._numerator = this._numerator.clone();
-            this._denominator = this._denominator.clone();
-            return this;
+            return new Rational(this._numerator.clone(), this._denominator.clone());
         };
         this.domain = () => {
             let zeroes = this._denominator.getZeroes();
@@ -3440,6 +3341,10 @@ class Rational {
         this.subtract = (R) => {
             return this.add(R.clone().opposed());
         };
+        this.euclidian = () => {
+            return this._numerator.euclidian(this._denominator);
+        };
+        // TODO : where and how is used limits ?
         this.limits = (value, offset, letter) => {
             if (value === Infinity || value === -Infinity) {
                 let { quotient, reminder } = this._numerator.clone().euclidian(this._denominator);
@@ -3480,26 +3385,151 @@ class Rational {
                 }
             }
         };
-        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).filter(x => !isNaN(x.value)), 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 '';
+        this.evaluate = (values) => {
+            const r = new fraction_1.Fraction().zero();
+            let N = this._numerator.evaluate(values), D = this._denominator.evaluate(values);
+            return N.divide(D);
+        };
+        this.study = () => {
+            return new rationalStudy_1.RationalStudy(this);
+        };
+        if (numerator instanceof polynom_1.Polynom) {
+            this._numerator = numerator.clone();
+        }
+        else if (typeof numerator === 'string') {
+            this._numerator = new polynom_1.Polynom(numerator);
+        }
+        else {
+            this._numerator = new polynom_1.Polynom();
+        }
+        if (denominator instanceof polynom_1.Polynom) {
+            this._denominator = denominator.clone();
+        }
+        else if (typeof denominator === 'string') {
+            this._denominator = new polynom_1.Polynom(denominator);
+        }
+        else {
+            this._denominator = new polynom_1.Polynom();
+        }
+    }
+    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} }`;
+    }
+    get plotFunction() {
+        return `(${this._numerator.plotFunction})/(${this._denominator.plotFunction})`;
+    }
+}
+exports.Rational = Rational;
+
+
+/***/ }),
+
+/***/ 996:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/**
+ * Rational polynom module contains everything necessary to handle rational polynoms.
+ * @module Polynom
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Study = exports.TABLE_OF_SIGNS = exports.FUNCTION_EXTREMA = exports.ASYMPTOTE = exports.ZEROTYPE = void 0;
+const fraction_1 = __webpack_require__(506);
+var ZEROTYPE;
+(function (ZEROTYPE) {
+    ZEROTYPE["ZERO"] = "z";
+    ZEROTYPE["DEFENCE"] = "d";
+    ZEROTYPE["NOTHING"] = "t";
+})(ZEROTYPE = exports.ZEROTYPE || (exports.ZEROTYPE = {}));
+var ASYMPTOTE;
+(function (ASYMPTOTE) {
+    ASYMPTOTE["VERTICAL"] = "av";
+    ASYMPTOTE["HORIZONTAL"] = "ah";
+    ASYMPTOTE["SLOPE"] = "ao";
+    ASYMPTOTE["HOLE"] = "hole";
+})(ASYMPTOTE = exports.ASYMPTOTE || (exports.ASYMPTOTE = {}));
+var FUNCTION_EXTREMA;
+(function (FUNCTION_EXTREMA) {
+    FUNCTION_EXTREMA["MIN"] = "min";
+    FUNCTION_EXTREMA["MAX"] = "max";
+    FUNCTION_EXTREMA["FLAT"] = "flat";
+    FUNCTION_EXTREMA["NOTHING"] = "";
+})(FUNCTION_EXTREMA = exports.FUNCTION_EXTREMA || (exports.FUNCTION_EXTREMA = {}));
+var TABLE_OF_SIGNS;
+(function (TABLE_OF_SIGNS) {
+    TABLE_OF_SIGNS[TABLE_OF_SIGNS["DEFAULT"] = 0] = "DEFAULT";
+    TABLE_OF_SIGNS[TABLE_OF_SIGNS["GROWS"] = 1] = "GROWS";
+    TABLE_OF_SIGNS[TABLE_OF_SIGNS["VARIATIONS"] = 2] = "VARIATIONS";
+})(TABLE_OF_SIGNS = exports.TABLE_OF_SIGNS || (exports.TABLE_OF_SIGNS = {}));
+/**
+ * The study class is a "function study" class that will get:
+ * fx               : get the function
+ * domain           : string
+ * zeroes           : Object (tex, IZero)
+ * signs            : table of signs + tex output  using tkz-tab
+ * av               : vertical asymptotic
+ * ah               : horizontal asymptotic
+ * ao               : obliques
+ * deltaX           : position relative
+ * dx               : derivative
+ * grows            : growing table + tex output  using tkz-tab
+ * ddx              : dérivée seconde
+ * variations       : variation table + tex output  using tkz-tab
+ */
+class Study {
+    constructor(fx) {
+        this.makeStudy = () => {
+            this._zeroes = this.makeZeroes();
+            this._signs = this.makeSigns();
+            this._asymptotes = this.makeAsymptotes();
+            this._derivative = this.makeDerivative();
+            this._variations = this.makeVariation();
+        };
+        this.indexOfZero = (zeroes, zero) => {
+            for (let i = 0; i < zeroes.length; i++) {
+                if (zeroes[i].tex === zero.tex) {
+                    return i;
+                }
+            }
+            return -1;
+        };
+        this.makeOneLineForSigns = (factor, zeroes, zeroSign) => {
+            let oneLine = [], currentZero = factor.getZeroes().map(x => x.tex);
+            // First +/- sign, before the first zero
+            oneLine.push('');
+            if (factor.degree().isZero()) {
+                oneLine.push(factor.monoms[0].coefficient.sign() === 1 ? '+' : '-');
+            }
+            else {
+                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 : ZEROTYPE.NOTHING);
+                // + / - sign after the current zero
+                if (i < zeroes.length - 1) {
+                    oneLine.push(factor.evaluate((zeroes[i].value + zeroes[i + 1].value) / 2).sign() === 1 ? '+' : '-');
                 }
-                if (index === tableOfSigns[0].length - 1) {
+                else if (i === zeroes.length - 1) {
+                    oneLine.push(factor.evaluate(zeroes[i].value + 1).sign() === 1 ? '+' : '-');
+                }
+            }
+            oneLine.push('');
+            return oneLine;
+        };
+        this.makeSignsResult = (signs) => {
+            // Initialize the result line with the first line of the signs table
+            let resultLine = signs[0].map((x, index) => {
+                if (index === 0 || index === signs[0].length - 1) {
                     return '';
                 }
                 if (index % 2 === 0) {
@@ -3507,7 +3537,8 @@ class Rational {
                 }
                 return '+';
             });
-            for (let current of tableOfSigns) {
+            // Go through each lines (except the first)
+            for (let current of signs) {
                 for (let i = 0; i < current.length; i++) {
                     if (i % 2 === 0) {
                         // t, z or d
@@ -3526,93 +3557,349 @@ class Rational {
                     }
                 }
             }
-            // 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;
+            return resultLine;
+        };
+        this.makeGrowsResult = (fx, tos) => {
+            // Use the last line (=> resultLine) to grab the necessary information
+            let signsAsArray = Object.values(tos.signs), resultLine = signsAsArray[signsAsArray.length - 1], growsLine = [], extremes = {}, zeroes = tos.zeroes;
+            // Get the extremes
+            for (let i = 0; i < zeroes.length; i++) {
+                // Get the corresponding item in the resultLine.
+                let pos = 2 * i + 2;
+                if (resultLine[pos] === 'z') {
+                    // It's a zero. Get the coordinates
+                    let x, y, zero = zeroes[i].exact, pt, xTex, yTex, pointType;
+                    if (zero instanceof fraction_1.Fraction) {
+                        let value = zero, evalY = fx.evaluate(value);
+                        x = zero.value;
+                        y = evalY.value;
+                        xTex = zero.tex;
+                        yTex = evalY.tex;
+                    }
+                    else {
+                        x = zeroes[i].value;
+                        y = fx.evaluate(zeroes[i].value).value;
+                        xTex = x.toFixed(2);
+                        yTex = y.toFixed(2);
+                    }
+                    // Determine the type of the zero.
+                    if (resultLine[pos - 1] === resultLine[pos + 1]) {
+                        pointType = FUNCTION_EXTREMA.FLAT;
+                    }
+                    else if (resultLine[pos - 1] === '+') {
+                        pointType = FUNCTION_EXTREMA.MAX;
+                    }
+                    else {
+                        pointType = FUNCTION_EXTREMA.MIN;
+                    }
+                    // Add the point to the list
+                    extremes[zeroes[i].tex] = {
+                        type: pointType,
+                        tex: { x: xTex, y: yTex },
+                        value: { x, y }
+                    };
+                }
+            }
+            // Create the grows line, based on tkz-tab
+            // \tkzTabLine{  ,  +  ,  z    ,  -  ,  d  ,  -  ,  z  ,  +  ,  }
+            // \tkzTabVar{     -/  , +/$3$ ,       -D+/ , -/$1$  , +/  }
+            growsLine.push(resultLine[1] === '+' ? '-/' : '+/');
+            for (let i = 1; i < resultLine.length - 1; i++) {
+                if (resultLine[i] === "z") {
+                    let extr = extremes[zeroes[(i - 2) / 2].tex];
+                    growsLine.push(`${resultLine[i - 1]}/\\(${extr.type}(${extr.tex.x};${extr.tex.y})\\)`);
+                }
+                else if (resultLine[i] === 'd') {
+                    growsLine.push(`${resultLine[i - 1]}D${resultLine[i + 1] === '+' ? '-' : '+'}/`);
+                }
+            }
+            growsLine.push(`${resultLine[resultLine.length - 2]}/`);
+            return { growsLine, extremes };
+        };
+        this.makeVariationsResult = (fx, tos) => {
+            // TODO: make variations result is not yet implemented.
+            let extremes = {}, varsLine = [];
+            return { varsLine, extremes };
         };
         this._makeTexFromTableOfSigns = (tos) => {
+            let factors = tos.factors.map(x => `\\(${x.tex}\\)/1`), factorsFx = "\\(fx\\)/1.2", zeroes = tos.zeroes;
+            // Add the last lines "label"
+            if (tos.type === TABLE_OF_SIGNS.GROWS) {
+                factorsFx = "\\(f'(x)\\)/1.2,\\(f(x)\\)/2";
+            }
+            else if (tos.type === TABLE_OF_SIGNS.VARIATIONS) {
+                factorsFx = "\\(f''(x)\\)/1.2,\\(f(x)\\)/2";
+            }
+            // Create the tikzPicture header
             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(',')}}`);
-            });
+\\tkzTabInit[lgt=3,espcl=2,deltacl=0]{/1.2,${factors.join(',')},/.1,${factorsFx} }{{\\scriptsize \\hspace{1cm} \\(-\\infty\\)},\\(${zeroes.map(x => x.tex).join('\\),\\(')}\\),{\\scriptsize \\hspace{-1cm} \\(+\\infty\\)}}`;
+            let pos;
+            for (pos = 0; pos < tos.factors.length; pos++) {
+                tex += (`\n\\tkzTabLine{${tos.signs[pos].join(',')}}`);
+            }
+            // Add the result line
+            tex += (`\n\\tkzTabLine{${tos.signs[pos].join(',')}}`);
+            // Add the grows / vars line
+            if (tos.type === TABLE_OF_SIGNS.GROWS) {
+                tex += (`\n\\tkzTabVar{${tos.signs[pos + 1].join(',')}}`);
+            }
+            else if (tos.type === TABLE_OF_SIGNS.VARIATIONS) {
+                // TODO: Check variations table for as tex
+                tex += (`\n\\tkzTabVar{${tos.signs[pos + 1].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('');
-            if (factor.degree().isZero()) {
-                oneLine.push(factor.monoms[0].coefficient.sign() === 1 ? '+' : '-');
+        this.fx = fx;
+        this.makeStudy();
+        return this;
+    }
+    get zeroes() {
+        return this._zeroes;
+    }
+    get domain() {
+        return this.fx.domain();
+    }
+    get signs() {
+        return this._signs;
+    }
+    get asymptotes() {
+        return this._asymptotes;
+    }
+    get derivative() {
+        return this._derivative;
+    }
+    get tex() {
+        return this._makeTexFromTableOfSigns(this._signs);
+    }
+    get texGrows() {
+        return this._makeTexFromTableOfSigns(this._derivative);
+    }
+    get texVariations() {
+        return this._makeTexFromTableOfSigns(this._variations);
+    }
+    makeZeroes() {
+        return [];
+    }
+    ;
+    makeSigns() {
+        return {
+            type: TABLE_OF_SIGNS.DEFAULT,
+            fx: null,
+            factors: [],
+            zeroes: [],
+            signs: [],
+            extremes: {}
+        };
+    }
+    ;
+    makeAsymptotes() {
+        return [];
+    }
+    makeDerivative() {
+        return {
+            type: TABLE_OF_SIGNS.GROWS,
+            fx: null,
+            factors: [],
+            zeroes: [],
+            signs: [],
+            extremes: {}
+        };
+    }
+    makeVariation() {
+        return {
+            type: TABLE_OF_SIGNS.VARIATIONS,
+            fx: null,
+            factors: [],
+            zeroes: [],
+            signs: [],
+            extremes: {}
+        };
+    }
+}
+exports.Study = Study;
+
+
+/***/ }),
+
+/***/ 572:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.RationalStudy = void 0;
+/**
+ * The study class is a "function study" class that will get:
+ * fx               : get the function
+ * domain           : string
+ * zeroes           : Object (tex, IZero)
+ * signs            : table of signs + tex output  using tkz-tab
+ * av               : vertical asymptotic
+ * ah               : horizontal asymptotic
+ * ao               : obliques
+ * deltaX           : position relative
+ * dx               : derivative
+ * grows            : growing table + tex output  using tkz-tab
+ * ddx              : dérivée seconde
+ * variations       : variation table + tex output  using tkz-tab
+ */
+const study_1 = __webpack_require__(996);
+const rational_1 = __webpack_require__(107);
+const fraction_1 = __webpack_require__(506);
+class RationalStudy extends study_1.Study {
+    constructor(fx) {
+        console.log('RATIONAL STUDY');
+        super(fx);
+        return this;
+    }
+    makeZeroes() {
+        console.log('GETTING ZEROES');
+        return this._getZeroes(this.fx);
+    }
+    ;
+    makeSigns() {
+        return this._getSigns(this.fx, this.zeroes);
+    }
+    ;
+    makeAsymptotes() {
+        const reduced = this.fx.clone().reduce();
+        // Vertical
+        let asymptotes = [];
+        this.zeroes.filter(x => x.type === study_1.ZEROTYPE.DEFENCE).forEach(zero => {
+            // Check if it's a hole or an asymptote
+            // TODO: Check for a hole ! Means calculate the limits !
+            let Ztype = study_1.ASYMPTOTE.VERTICAL, tex = `x=${zero.tex}`;
+            if (zero.exact instanceof fraction_1.Fraction) {
+                if (reduced.denominator.evaluate(zero.exact).isNotZero()) {
+                    Ztype = study_1.ASYMPTOTE.HOLE;
+                    tex = `(${zero.tex};${reduced.evaluate(zero.exact).tex})`;
+                }
             }
             else {
-                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 ? '+' : '-');
+                if (reduced.denominator.evaluate(zero.value).isNotZero()) {
+                    Ztype = study_1.ASYMPTOTE.HOLE;
+                    tex = `(${zero.tex};${reduced.evaluate(zero.value).tex})`;
                 }
             }
-            oneLine.push('');
-            return oneLine;
-        };
-        this.evaluate = (values) => {
-            const r = new fraction_1.Fraction().zero();
-            let N = this._numerator.evaluate(values), D = this._numerator.evaluate(values);
-            return N.divide(D);
-        };
-        if (numerator instanceof polynom_1.Polynom) {
-            this._numerator = numerator.clone();
-        }
-        else if (typeof numerator === 'string') {
-            this._numerator = new polynom_1.Polynom(numerator);
-        }
-        else {
-            this._numerator = new polynom_1.Polynom();
-        }
-        if (denominator instanceof polynom_1.Polynom) {
-            this._denominator = denominator.clone();
+            asymptotes.push({
+                type: Ztype,
+                tex: tex,
+                zero: zero,
+                limits: `\\lim_{x\\to${zero.tex} }\\ f(x) = \\pm\\infty`,
+                deltaX: null
+            });
+        });
+        // Sloped asymptote
+        let NDegree = this.fx.numerator.degree(), DDegree = this.fx.denominator.degree();
+        if (NDegree.isEqual(DDegree)) {
+            let H = this.fx.numerator.monomByDegree().coefficient.clone().divide(this.fx.denominator.monomByDegree().coefficient).tex;
+            let { reminder } = reduced.euclidian();
+            asymptotes.push({
+                type: study_1.ASYMPTOTE.HORIZONTAL,
+                tex: `y=${H}`,
+                zero: null,
+                limits: `\\lim_{x\\to\\infty}\\ f(x) = ${H}`,
+                deltaX: new rational_1.Rational(reminder, reduced.denominator)
+            });
         }
-        else if (typeof denominator === 'string') {
-            this._denominator = new polynom_1.Polynom(denominator);
+        else if (DDegree.greater(NDegree)) {
+            asymptotes.push({
+                type: study_1.ASYMPTOTE.HORIZONTAL,
+                tex: `y=0`,
+                zero: null,
+                limits: `\\lim_{x\\to\\infty}\\ f(x) = ${0}`,
+                deltaX: null
+            });
         }
-        else {
-            this._denominator = new polynom_1.Polynom();
+        else if (NDegree.value - 1 === DDegree.value) {
+            // Calculate the slope
+            let { quotient, reminder } = reduced.euclidian();
+            asymptotes.push({
+                type: study_1.ASYMPTOTE.SLOPE,
+                tex: `y=${quotient.tex}`,
+                zero: null,
+                limits: ``,
+                deltaX: new rational_1.Rational(reminder, reduced.denominator)
+            });
         }
+        return asymptotes;
     }
-    get numerator() {
-        return this._numerator;
-    }
-    get denominator() {
-        return this._denominator;
-    }
-    get tex() {
-        return `\\frac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
+    ;
+    makeDerivative() {
+        let dx = this.fx.clone().derivative(), tos = this._getSigns(dx, this._getZeroes(dx), study_1.TABLE_OF_SIGNS.GROWS);
+        console.log(tos.factors.length, tos.signs.length);
+        let result = this.makeGrowsResult(this.fx, tos);
+        tos.signs.push(result.growsLine);
+        tos.extremes = result.extremes;
+        console.log(tos.signs.length);
+        return tos;
     }
-    get texFactors() {
-        return `\\frac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`;
+    ;
+    makeVariation() {
+        // Get the zeroes, make signs.
+        let dx = this.derivative.fx.clone().derivative(), tos = this._getSigns(dx, this._getZeroes(dx), study_1.TABLE_OF_SIGNS.VARIATIONS);
+        let result = this.makeVariationsResult(this.fx, tos);
+        tos.signs.push(result.varsLine);
+        tos.extremes = result.extremes;
+        return tos;
     }
-    get plotFunction() {
-        return `(${this._numerator.plotFunction})/(${this._denominator.plotFunction})`;
+    ;
+    _getZeroes(fx) {
+        // All zeroes.
+        let zeroes = [];
+        fx.numerator.getZeroes().filter(x => !isNaN(x.value)).forEach(z => {
+            // add the item
+            zeroes.push({
+                tex: z.tex,
+                value: z.value,
+                exact: z.exact,
+                extrema: study_1.FUNCTION_EXTREMA.NOTHING,
+                type: study_1.ZEROTYPE.ZERO
+            });
+        });
+        fx.denominator.getZeroes().filter(x => !isNaN(x.value)).forEach(z => {
+            let idx = this.indexOfZero(zeroes, z);
+            if (idx !== -1) {
+                zeroes[idx].type = study_1.ZEROTYPE.DEFENCE;
+            }
+            else {
+                // Add the item
+                zeroes.push({
+                    tex: z.tex,
+                    value: z.value,
+                    exact: z.exact,
+                    extrema: study_1.FUNCTION_EXTREMA.NOTHING,
+                    type: study_1.ZEROTYPE.DEFENCE
+                });
+            }
+        });
+        // sort all zeroes
+        zeroes.sort((a, b) => a.value - b.value);
+        return zeroes;
+    }
+    _getSigns(fx, zeroes, typeOfTable) {
+        // Factorize the rational
+        let signs = [], factors = [];
+        fx.numerator.factors.forEach(factor => {
+            signs.push(this.makeOneLineForSigns(factor, zeroes, study_1.ZEROTYPE.ZERO));
+            factors.push(factor.clone());
+        });
+        fx.denominator.factors.forEach(factor => {
+            signs.push(this.makeOneLineForSigns(factor, zeroes, study_1.ZEROTYPE.DEFENCE));
+            factors.push(factor.clone());
+        });
+        signs.push(this.makeSignsResult(signs));
+        return {
+            type: typeOfTable,
+            fx,
+            factors,
+            zeroes,
+            signs,
+            extremes: {}
+        };
     }
 }
-exports.Rational = Rational;
+exports.RationalStudy = RationalStudy;
 
 
 /***/ }),