pimath 0.0.127 → 0.0.129

package/esm/maths/algebra/polynom.js

@@ -1,1305 +0,0 @@
-"use strict";
-/**
- * Polynom module contains everything necessary to handle polynoms.*
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Polynom = void 0;
-const monom_1 = require("./monom");
-const shutingyard_1 = require("../shutingyard");
-const numeric_1 = require("../numeric");
-const fraction_1 = require("../coefficients/fraction");
-const equation_1 = require("./equation");
-/**
- * Polynom class can handle polynoms, reorder, resolve, ...
- * ```
- * let P = new Polynom('3x-4')
- * ```
- */
-class Polynom {
-    /**
-     *
-     * @param {string} polynomString (optional) Default polynom to parse on class creation
-     * @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:
-                    stack.push(new Polynom(element.token));
-                    break;
-                case shutingyard_1.ShutingyardType.VARIABLE:
-                    stack.push(new Polynom().add(new monom_1.Monom(element.token)));
-                    break;
-                case shutingyard_1.ShutingyardType.CONSTANT:
-                    // TODO: add constant support to Polynom parsing.
-                    console.log('Actually, not supported - will be added later !');
-                    break;
-                case shutingyard_1.ShutingyardType.OPERATION:
-                    if (stack.length >= 2) {
-                        const b = stack.pop(), a = stack.pop();
-                        if (element.token === '+') {
-                            stack.push(a.add(b));
-                        }
-                        else if (element.token === '-') {
-                            stack.push(a.subtract(b));
-                        }
-                        else if (element.token === '*') {
-                            stack.push(a.multiply(b));
-                        }
-                        else if (element.token === '/') {
-                            if (b.degree().isStrictlyPositive()) {
-                                console.log('divide by a polynom -> should create a rational polynom !');
-                            }
-                            else {
-                                stack.push(a.divide(b.monoms[0].coefficient));
-                            }
-                        }
-                        else if (element.token === '^') {
-                            if (b.degree().isStrictlyPositive()) {
-                                console.error('Cannot elevate a polynom with another polynom !', a.tex, b.tex);
-                            }
-                            else {
-                                if (b.monoms[0].coefficient.isRelative()) {
-                                    // Integer power
-                                    stack.push(a.pow(b.monoms[0].coefficient.value));
-                                }
-                                else {
-                                    // Only allow power if the previous polynom is only a monom, without coefficient.
-                                    if (a.monoms.length === 1 && a.monoms[0].coefficient.isOne()) {
-                                        for (let letter in a.monoms[0].literal) {
-                                            a.monoms[0].literal[letter].multiply(b.monoms[0].coefficient);
-                                        }
-                                        stack.push(a);
-                                    }
-                                    else {
-                                        console.error('Cannot have power with fraction');
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        if (element.token === '-') {
-                            stack.push(stack.pop().opposed());
-                        }
-                        else {
-                            throw "Error parsing the polynom " + this._rawString;
-                        }
-                    }
-                    break;
-                case shutingyard_1.ShutingyardType.MONOM:
-                    // Should never appear.
-                    console.error('The monom token should not appear here');
-                    break;
-                case shutingyard_1.ShutingyardType.FUNCTION:
-                    // Should never appear.
-                    console.error('The function token should not appear here - might be introduced later.');
-                    break;
-            }
-        };
-        // ------------------------------------------
-        // Creation / parsing functions
-        // ------------------------------------------
-        /**
-         * Parse a string to a polynom.
-         * @param inputStr
-         * @param values: as string, numbers or fractions
-         */
-        this.parse = (inputStr, ...values) => {
-            // Reset the main variables.
-            this._monoms = [];
-            this._factors = [];
-            this.mark_as_dirty();
-            // TODO: allow to enter a liste of Fraction (a, b, c, ...) to make a polynom ax^n + bx^(n-1) + cx^(n-2) + ...
-            if (typeof inputStr === 'string') {
-                return this._parseString(inputStr, ...values);
-            }
-            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) {
-                    this._monoms.push(m.clone());
-                }
-            }
-            return this;
-        };
-        /**
-         * Clone the polynom
-         */
-        this.clone = () => {
-            const P = new Polynom();
-            const M = [];
-            for (const m of this._monoms) {
-                M.push(m.clone());
-            }
-            P.monoms = M;
-            return P;
-        };
-        /**
-         * Set the polynom to zero.
-         * @returns {this}
-         */
-        this.zero = () => {
-            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;
-        };
-        // ------------------------------------------
-        // Mathematical operations
-        this.add = (...values) => {
-            this.mark_as_dirty();
-            // @ts-ignore
-            for (let value of values) {
-                if (value instanceof Polynom) {
-                    this._monoms = this._monoms.concat(value.monoms);
-                }
-                else if (value instanceof monom_1.Monom) {
-                    this._monoms.push(value.clone());
-                }
-                else if (Number.isSafeInteger(value)) {
-                    this._monoms.push(new monom_1.Monom(value.toString()));
-                }
-                else {
-                    this._monoms.push(new monom_1.Monom(value));
-                }
-            }
-            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);
-                }
-                else if (value instanceof monom_1.Monom) {
-                    this._monoms.push(value.clone().opposed());
-                }
-                else if (Number.isSafeInteger(value)) {
-                    this._monoms.push(new monom_1.Monom(value.toString()).opposed());
-                }
-                else {
-                    this._monoms.push(new monom_1.Monom(value).opposed());
-                }
-            }
-            return this.reduce();
-        };
-        this.multiply = (value) => {
-            this.mark_as_dirty();
-            if (value instanceof Polynom) {
-                return this.multiplyByPolynom(value);
-            }
-            else if (value instanceof fraction_1.Fraction) {
-                return this.multiplyByFraction(value);
-            }
-            else if (value instanceof monom_1.Monom) {
-                return this.multiplyByMonom(value);
-            }
-            else if (Number.isSafeInteger(value) && typeof value === 'number') {
-                return this.multiplyByInteger(value);
-            }
-            // Something went wrong...
-            return this;
-        };
-        /**
-         * Divide the current polynom by another polynom.
-         * @param P
-         * 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);
-            // There is no variable - means it's a number
-            if (P.variables.length === 0) {
-                let q = this.clone().divide(P);
-                return {
-                    quotient: this.clone().divide(P).reduce(),
-                    reminder: new Polynom().zero()
-                };
-            }
-            // Get at least a letter
-            const maxMP = P.monomByDegree(undefined, letter);
-            const degreeP = P.degree(letter);
-            let newM;
-            // Make the euclidian division of the two polynoms.
-            let MaxIteration = this.degree(letter).value * 2;
-            while (reminder.degree(letter).geq(degreeP) && MaxIteration > 0) {
-                MaxIteration--;
-                // Get the greatest monom divided by the max monom of the divider
-                newM = reminder.monomByDegree(undefined, letter).clone().divide(maxMP);
-                if (newM.isZero())
-                    break;
-                // Get the new quotient and reminder.
-                quotient.add(newM);
-                reminder.subtract(P.clone().multiply(newM));
-                // Check if the reminder is zero.
-                if (newM.degree(letter).isZero())
-                    break;
-            }
-            quotient.reduce();
-            reminder.reduce();
-            return { quotient, reminder };
-        };
-        this.divide = (value) => {
-            this.mark_as_dirty();
-            if (value instanceof fraction_1.Fraction) {
-                return this.divideByFraction(value);
-            }
-            else if (typeof value === 'number' && Number.isSafeInteger(value)) {
-                return this.divideByInteger(value);
-            }
-            else if (value instanceof monom_1.Monom) {
-                return this.divide(new Polynom(value));
-            }
-            else if (value instanceof Polynom) {
-                if (value.monoms.length === 1 && value.variables.length === 0) {
-                    return this.divideByFraction(value.monoms[0].coefficient);
-                }
-                else {
-                    let { quotient, reminder } = this.euclidian(value);
-                    if (reminder.isZero()) {
-                        return quotient;
-                    }
-                    else {
-                        console.log(`${this.tex} is not divideable by ${value.tex}`);
-                        return new Polynom().zero();
-                    }
-                }
-            }
-        };
-        this.pow = (nb) => {
-            this.mark_as_dirty();
-            if (!Number.isSafeInteger(nb)) {
-                return this.zero();
-            }
-            if (nb < 0) {
-                return this.zero();
-            }
-            if (nb === 0) {
-                return new Polynom();
-            }
-            const P = this.clone();
-            for (let i = 1; i < nb; i++) {
-                this.multiply(P);
-            }
-            return this.reduce();
-        };
-        // ------------------------------------------
-        /**
-         * Compare the current coefficient with another coefficient
-         * @param P
-         * @param sign (string| default is =): authorized values: =, <, <=, >, >= with some variations.
-         */
-        this.compare = (P, sign) => {
-            if (sign === undefined) {
-                sign = '=';
-            }
-            // Create clone version to reduce them without altering the original polynoms.
-            const cP1 = this.clone().reduce().reorder();
-            const cP2 = P.clone().reduce().reorder();
-            switch (sign) {
-                case '=':
-                    // They must have the isSame length and the isSame degree
-                    if (cP1.length !== cP2.length || cP1.degree().isNotEqual(cP2.degree())) {
-                        return false;
-                    }
-                    // Check if the coefficients are the isSame.
-                    for (const i in cP1.monoms) {
-                        if (!cP1.monoms[i].isEqual(cP2.monoms[i])) {
-                            return false;
-                        }
-                    }
-                    return true;
-                case 'same':
-                    // They must have the isSame length and the isSame degree
-                    if (cP1.length !== cP2.length || cP1.degree() !== cP2.degree()) {
-                        return false;
-                    }
-                    for (const i in cP1.monoms) {
-                        if (!cP1.monoms[i].isSameAs(cP2.monoms[i])) {
-                            return false;
-                        }
-                    }
-                    return true;
-                default:
-                    return false;
-            }
-        };
-        this.isEqual = (P) => {
-            return this.compare(P, '=');
-        };
-        this.isSameAs = (P) => {
-            return this.compare(P, 'same');
-        };
-        this.isOpposedAt = (P) => {
-            return this.compare(P.clone().opposed(), '=');
-        };
-        this.isFactorized = (polynomString, soft) => {
-            let P;
-            // Check if polynom is complete...
-            if (polynomString.split('(').length !== polynomString.split(')').length) {
-                return false;
-            }
-            // Try to build the polynom
-            try {
-                P = new Polynom(polynomString);
-            }
-            catch (e) {
-                return false;
-            }
-            // Both polynom aren't the same (once developed and reduced => they cannot be equivalent)
-            if (!this.isEqual(P)) {
-                return false;
-            }
-            // Check if the provided (string) version is fully factorized.
-            // Run a regex on the string.
-            let polynomStringNormalized = polynomString.replaceAll('*', ''), polynomStringReduced = '' + polynomStringNormalized, factors = [];
-            for (let x of polynomStringNormalized.matchAll(/\(([a-z0-9+\-]+)\)(\^[0-9]*)?/g)) {
-                if (x[2] !== undefined) {
-                    // if there is an exponential value, add it multiple times
-                    for (let i = 0; i < +x[2].substring(1); i++) {
-                        factors.push(x[1]);
-                    }
-                }
-                else {
-                    // no power - add it once.
-                    factors.push(x[1]);
-                }
-                // Remove the current polynom
-                polynomStringReduced = polynomStringReduced.replaceAll(x[0], '');
-            }
-            if (polynomStringReduced !== '') {
-                factors.push(polynomStringReduced);
-            }
-            let polyFactors = factors.map(x => new Polynom(x));
-            // polyFactors contain all polynoms.
-            let checkPolyFactors = polyFactors.filter(x => x.degree().geq(1) && !x.commonMonom().isOne());
-            // Some polynoms are not completely factorized.
-            if (checkPolyFactors.length > 0 && !soft) {
-                return false;
-            }
-            if (checkPolyFactors.length > 0 && soft) {
-                polyFactors = polyFactors.filter(x => x.commonMonom().isOne());
-                let FactorizedConstant = new fraction_1.Fraction().one();
-                for (let p of checkPolyFactors) {
-                    let k = p.commonMonom(), pFactor = p.clone().divide(k);
-                    if (k.degree().isZero()) {
-                        FactorizedConstant.multiply(k.coefficient);
-                        polyFactors.push(pFactor.clone());
-                    }
-                }
-            }
-            // Factorize the current polynom.
-            this.factorize();
-            // Compare the given factors with the generated factors
-            let sign = 1, notFoundedFactors = [];
-            for (let f of this.factors) {
-                // The factor is just a coefficient. Might be opposed
-                if (f.degree().isZero()) {
-                    if (f.monoms[0].coefficient.isNegativeOne()) {
-                        sign = -sign;
-                    }
-                }
-                let factorFound = false;
-                for (let i = 0; i < polyFactors.length; i++) {
-                    if (f.isEqual(polyFactors[i])) {
-                        polyFactors.splice(i, 1);
-                        factorFound = true;
-                        break;
-                    }
-                    else if (f.isOpposedAt(polyFactors[i])) {
-                        polyFactors.splice(i, 1);
-                        sign = -sign;
-                        factorFound = true;
-                        break;
-                    }
-                }
-                if (!factorFound) {
-                    notFoundedFactors.push(f.clone());
-                }
-            }
-            // The polyfactors must be empty and the cumulative opposite factors must be 1.
-            return (polyFactors.length === 0 && sign === 1);
-        };
-        // ------------------------------------------
-        // Compare functions
-        this.isReduced = (polynomString) => {
-            // The polynom must be developed to be reduced.
-            if (!this.isDeveloped(polynomString)) {
-                return false;
-            }
-            let P = new Polynom(polynomString);
-            if (P.monoms.length > this.monoms.length) {
-                return false;
-            }
-            // TODO: Not ur the reduced systme checking is working properly !
-            for (let m of P.monoms) {
-                if (!m.coefficient.isReduced()) {
-                    return false;
-                }
-            }
-            return false;
-        };
-        this.isDeveloped = (polynomString) => {
-            let P;
-            // Start by removing the parenthis after a "power"
-            let pString = polynomString.replaceAll(/\^\(([-0-9/]+)\)/g, '$1');
-            // There is at least one parenthese - it is not developed.
-            if (pString.includes('(') || pString.includes(')')) {
-                return false;
-            }
-            // Try to build the polynom
-            try {
-                // Build the polynom
-                P = new Polynom(polynomString);
-            }
-            catch (e) {
-                return false;
-            }
-            // Both polynom aren't the same (once developed and reduced => they cannot be equivalent)
-            if (!this.isEqual(P)) {
-                return false;
-            }
-            // Check that everything is completely developed. Actually, there are no parentheses... so it is fully developed
-            return true;
-            // // maybe it wasn't reduced and not ordered...
-            // // compare polynom string.
-            //
-            // // normalize the string
-            // let polynomStringNormalized = polynomString.replaceAll('[*\s]', '')
-            //
-            // // Determine if it's the exact same string.
-            // // TODO: Maybe it's enough to just make this test !a
-            // return polynomStringNormalized === P.reduce().reorder().display
-        };
-        // -------------------------------------
-        this.reduce = () => {
-            // Reduce the polynom
-            let values = this._monoms.map(x => x.clone()), vars = [...this.variables];
-            // Group the monoms by similarity
-            let i = 0;
-            while (i < this._monoms.length) {
-                for (let j = i + 1; j < this._monoms.length; j++) {
-                    if (this._monoms[i].isSameAs(this._monoms[j])) {
-                        this._monoms[i].add(this._monoms[j]);
-                        this._monoms.splice(j, 1);
-                        if (this._monoms[i].isZero()) {
-                            this._monoms[i] = new monom_1.Monom().zero();
-                        }
-                        j--;
-                    }
-                }
-                i++;
-            }
-            //
-            //
-            //
-            // let coeffs = values.filter(x => x.variables.length === 0)
-            //
-            // if (coeffs.length > 0) {
-            //     this._monoms.push(coeffs.reduce((a, b) => a.add(b)))
-            // }
-            //
-            // // Build the new monoms
-            // for (let letter of vars) {
-            //     // Monom with same letters, but might be of different degrees
-            //     let M = values.filter(x => x.hasLetter(letter))
-            //
-            //     while (M.length > 0) {
-            //         // Take the first element
-            //         const m = M.shift(), degree = m.degree(letter)
-            //
-            //         for (let a of M.filter(x => x.degree(letter).isEqual(degree))) {
-            //             m.add(a)
-            //         }
-            //
-            //         this._monoms.push(m)
-            //
-            //         // Make the new array.
-            //         M = M.filter(x => x.degree(letter).isNotEqual(degree))
-            //     }
-            //     // reduce the monom
-            //
-            // }
-            // Remove all null monoms
-            this._monoms = this._monoms.filter((m) => {
-                return m.coefficient.value !== 0;
-            });
-            // Reduce all monoms coefficient.
-            for (const m of this._monoms) {
-                m.coefficient.reduce();
-            }
-            if (this.length === 0) {
-                return new Polynom().zero();
-            }
-            return this.reorder();
-        };
-        this.reorder = (letter = 'x', revert) => {
-            if (revert === undefined) {
-                revert = false;
-            }
-            // TODO: Must handle multiple setLetter reorder system
-            let otherLetters = this.variables.filter(x => x !== letter);
-            this._monoms.sort(function (a, b) {
-                let da = a.degree(letter).value, db = b.degree(letter).value;
-                // Values are different
-                if (da !== db)
-                    return revert ? da - db : db - da;
-                // if values are equals, check other letters - it must be revert in that case !
-                if (otherLetters.length > 0) {
-                    for (let L of otherLetters) {
-                        let da = a.degree(L).value, db = b.degree(L).value;
-                        // Values are different
-                        if (da !== db)
-                            return revert ? da - db : db - da;
-                    }
-                }
-                return 0;
-                // return b.degree(letter).clone().subtract(a.degree(letter)).value
-            });
-            return this;
-        };
-        this.degree = (letter) => {
-            let d = new fraction_1.Fraction().zero();
-            for (const m of this._monoms) {
-                d = fraction_1.Fraction.max(m.degree(letter).value, d);
-            }
-            return d;
-        };
-        this.letters = () => {
-            let L = [], S = new Set();
-            for (let m of this._monoms) {
-                S = new Set([...S, ...m.variables]);
-            }
-            // @ts-ignore
-            return [...S];
-        };
-        /**
-         * Replace a variable (letter) by a polynom.
-         * @param letter
-         * @param P
-         */
-        this.replaceBy = (letter, P) => {
-            this.mark_as_dirty();
-            let pow;
-            const resultPolynom = new Polynom().zero();
-            for (const m of this.monoms) {
-                if (m.literal[letter] === undefined || m.literal[letter].isZero()) {
-                    resultPolynom.add(m.clone());
-                }
-                else {
-                    // We have found a setLetter.
-                    // Get the power and reset it.
-                    pow = m.literal[letter].clone();
-                    delete m.literal[letter];
-                    // TODO: replaceBy works only with positive and natural pow
-                    resultPolynom.add(P.clone().pow(Math.abs(pow.numerator)).multiply(m));
-                }
-            }
-            this._monoms = resultPolynom.reduce().reorder().monoms;
-            return this;
-        };
-        // Evaluate a polynom.
-        this.evaluate = (values) => {
-            const r = new fraction_1.Fraction().zero();
-            this._monoms.forEach(monom => {
-                //console.log('Evaluate polynom: ', monom.display, values, monom.evaluate(values).display);
-                r.add(monom.evaluate(values));
-            });
-            return r;
-        };
-        this.evaluateAsNumeric = (values) => {
-            let r = 0;
-            this._monoms.forEach(monom => {
-                r += monom.evaluateAsNumeric(values);
-            });
-            return r;
-        };
-        this.derivative = (letter) => {
-            let dP = new Polynom();
-            for (let m of this._monoms) {
-                dP.add(m.derivative(letter));
-            }
-            return dP;
-        };
-        // ------------------------------------------
-        // Misc polynoms functions
-        this.primitive = (letter) => {
-            let dP = new Polynom();
-            for (let m of this._monoms) {
-                dP.add(m.primitive(letter));
-            }
-            return dP;
-        };
-        this.integrate = (a, b, letter) => {
-            const primitive = this.primitive(letter);
-            if (letter === undefined) {
-                letter = 'x';
-            }
-            let valuesA = {}, valuesB = {};
-            valuesA[letter] = new fraction_1.Fraction(a);
-            valuesB[letter] = new fraction_1.Fraction(b);
-            return primitive.evaluate(valuesB).subtract(primitive.evaluate(valuesA));
-        };
-        // -------------------------------------
-        /**
-         * Factorize a polynom and store the best results in factors.
-         * @param maxValue Defines the greatest value to search to (default is 20).
-         */
-        this.factorize = (letter) => {
-            if (!this.dirty_factors) {
-                return this._factors;
-            }
-            let factors = [];
-            let P = this.clone().reorder();
-            // Extract the common monom
-            // 2x^3+6x^2 => 2x^2
-            let M = P.commonMonom();
-            // If the polynom starts with a negative monom, factorize it.
-            if (P.monomByDegree().coefficient.isStrictlyNegative() && M.coefficient.isStrictlyPositive() && !M.isOne()) {
-                M.opposed();
-            }
-            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)
-                                return pX.isDivisible(dX);
-                            });
-                        }
-                    }
-                }
-            }
-            // Maybe there is still something in the Polynom (not everything was possible to factorize)
-            if (!P.isOne()) {
-                factors.push(P.clone());
-            }
-            // 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 {
-                    return false;
-                }
-            }
-            else {
-                this.euclidianCache[div.tex] = this.euclidian(div);
-                return this.euclidianCache[div.tex].reminder.isZero();
-            }
-        };
-        // TODO: get zeroes for more than first degree and for more than natural degrees
-        this.getZeroes = () => {
-            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) => {
-            if (degree === undefined) {
-                // return the highest degree monom.
-                return this.monomByDegree(this.degree(letter), letter);
-            }
-            // Reduce the polynom.
-            const M = this.clone().reduce();
-            for (const m of M._monoms) {
-                if (m.degree(letter).isEqual(degree)) {
-                    return m.clone();
-                }
-            }
-            // Nothing was found - return the null monom.
-            return new monom_1.Monom().zero();
-        };
-        this.monomsByDegree = (degree, letter) => {
-            if (degree === undefined) {
-                // return the highest degree monom.
-                return this.monomsByDegree(this.degree(letter));
-            }
-            // Reduce the polynom.
-            let Ms = [];
-            const M = this.clone().reduce();
-            for (const m of M._monoms) {
-                if (m.degree(letter) === degree) {
-                    Ms.push(m.clone());
-                }
-            }
-            return Ms;
-            // Nothing was found - retur
-        };
-        // Used in LinearSystem.tex
-        this.monomByLetter = (letter) => {
-            const M = this.clone().reduce();
-            for (const m of M._monoms) {
-                if (m.hasLetter(letter)) {
-                    return m.clone();
-                }
-            }
-            return new monom_1.Monom().zero();
-        };
-        // Next functions are used for for commonMonom, which is used in the factorize method.
-        this.getDenominators = () => {
-            const denominators = [];
-            for (const m of this._monoms) {
-                denominators.push(m.coefficient.denominator);
-            }
-            return denominators;
-        };
-        this.getNumerators = () => {
-            const numerators = [];
-            for (const m of this._monoms) {
-                numerators.push(m.coefficient.numerator);
-            }
-            return numerators;
-        };
-        this.lcmDenominator = () => {
-            return numeric_1.Numeric.lcm(...this.getDenominators());
-        };
-        // ------------------------------------------
-        // Polynoms factorization functions
-        this.gcdDenominator = () => {
-            return numeric_1.Numeric.gcd(...this.getDenominators());
-        };
-        this.lcmNumerator = () => {
-            return numeric_1.Numeric.lcm(...this.getNumerators());
-        };
-        this.gcdNumerator = () => {
-            return numeric_1.Numeric.gcd(...this.getNumerators());
-        };
-        // ------------------------------------------
-        // Polynoms helpers functions
-        // -------------------------------------
-        this.commonMonom = () => {
-            let M = new monom_1.Monom().one(), numerator, denominator, degree = this.degree();
-            numerator = this.gcdNumerator();
-            denominator = this.gcdDenominator();
-            M.coefficient = new fraction_1.Fraction(numerator, denominator);
-            for (let L of this.variables) {
-                // Initialize the setLetter with the max degree
-                M.setLetter(L, degree);
-                for (let m of this._monoms) {
-                    M.setLetter(L, fraction_1.Fraction.min(m.degree(L), M.degree(L)));
-                    if (M.degree(L).isZero()) {
-                        break;
-                    }
-                }
-            }
-            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._getAllPotentialFactors = (P, maxDegree, letter) => {
-            let m1 = P.monoms[0].dividers, m2 = P.monoms[P.monoms.length - 1].dividers;
-            let allDividers = [];
-            m1.forEach(m1d => {
-                // 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;
-        };
-        this.genDisplay = (output, forceSign, wrapParentheses, withAllMultSign) => {
-            let P = '';
-            for (const k of this._monoms) {
-                if (k.coefficient.value === 0) {
-                    continue;
-                }
-                // The monom to be displayed
-                let m;
-                if (withAllMultSign) {
-                    m = k.plotFunction;
-                }
-                else {
-                    m = (output === 'tex') ? k.tex : k.display;
-                }
-                P += `${(k.coefficient.sign() === 1 && (P !== '' || forceSign === true)) ? '+' : ''}${m}`;
-            }
-            if (wrapParentheses === true && this.length > 1) {
-                if (output === 'tex') {
-                    P = `\\left( ${P} \\right)`;
-                }
-                else {
-                    P = `(${P})`;
-                }
-            }
-            if (P === '') {
-                P = '0';
-            }
-            return P;
-        };
-        /**
-         * Main parse using a shutting yard class
-         * @param inputStr
-         */
-        this.shutingYardToReducedPolynom = (inputStr) => {
-            // Get the RPN array of the current expression
-            const SY = new shutingyard_1.Shutingyard().parse(inputStr);
-            const rpn = SY.rpn;
-            // New version for reducing shuting yard.
-            this.zero();
-            let stack = [], monom = new monom_1.Monom();
-            // Loop through the
-            for (const element of rpn) {
-                this.addToken(stack, element);
-            }
-            if (stack.length === 1) {
-                this.add(stack[0]);
-            }
-            return this.reorder();
-        };
-        this.multiplyByPolynom = (P) => {
-            const M = [];
-            for (const m1 of this._monoms) {
-                for (const m2 of P.monoms) {
-                    M.push(monom_1.Monom.xmultiply(m1, m2));
-                }
-            }
-            this._monoms = M;
-            return this.reduce();
-        };
-        this.multiplyByFraction = (F) => {
-            for (const m of this._monoms) {
-                m.coefficient.multiply(F);
-            }
-            return this.reduce();
-        };
-        this.multiplyByInteger = (nb) => {
-            return this.multiplyByFraction(new fraction_1.Fraction(nb));
-        };
-        this.multiplyByMonom = (M) => {
-            for (const m of this._monoms) {
-                m.multiply(M);
-            }
-            return this.reduce();
-        };
-        this.divideByInteger = (nb) => {
-            const nbF = new fraction_1.Fraction(nb);
-            for (const m of this._monoms) {
-                m.coefficient.divide(nbF);
-            }
-            return this;
-        };
-        this.divideByFraction = (F) => {
-            for (const m of this._monoms) {
-                m.coefficient.divide(F);
-            }
-            return this;
-        };
-        this._factorize2ndDegree = (letter) => {
-            let P1, P2, a, b, c, delta, x1, x2, factor;
-            // One variable only
-            if (this.numberOfVars === 1) {
-                a = this.monomByDegree(2, letter).coefficient;
-                b = this.monomByDegree(1, letter).coefficient;
-                c = this.monomByDegree(0, letter).coefficient;
-                delta = b.clone().pow(2).subtract(a.clone().multiply(c).multiply(4));
-                if (delta.isZero()) {
-                    x1 = b.clone().opposed().divide(a.clone().multiply(2));
-                    P1 = new Polynom(letter).subtract(x1.display).multiply(x1.denominator);
-                    P2 = new Polynom(letter).subtract(x1.display).multiply(x1.denominator);
-                    factor = a.divide(x1.denominator).divide(x1.denominator);
-                    if (!factor.isOne()) {
-                        // TODO: Update new Polynom to accept anything...
-                        return [new Polynom(factor.display), P1, P2];
-                    }
-                    else {
-                        return [P1, P2];
-                    }
-                }
-                else if (delta.isPositive() && delta.isSquare()) {
-                    x1 = b.clone().opposed()
-                        .add(delta.clone().sqrt())
-                        .divide(a.clone().multiply(2));
-                    x2 = b.clone().opposed()
-                        .subtract(delta.clone().sqrt())
-                        .divide(a.clone().multiply(2));
-                    // (2x+5)(3x-2)
-                    // 6x^2+11x-10
-                    // a = 6, b = 11, c = -10
-                    // delta = 121-4*6*(-10) = 361= 19^2
-                    // x1 = (-11 + 19)  / 12 = 8/12 = 2/3
-                    // x2 = (-11 - 19)  / 12 = -30/12 = -5/2
-                    factor = a.divide(x1.denominator).divide(x2.denominator);
-                    if (factor.isOne()) {
-                        return [
-                            new Polynom(letter).subtract(x1.display).multiply(x1.denominator),
-                            new Polynom(letter).subtract(x2.display).multiply(x2.denominator),
-                        ];
-                    }
-                    else {
-                        return [
-                            new Polynom(factor.display),
-                            new Polynom(letter).subtract(x1.display).multiply(x1.denominator),
-                            new Polynom(letter).subtract(x2.display).multiply(x2.denominator),
-                        ];
-                    }
-                }
-                else {
-                    // No solution possible - return the complete value.
-                    return [this.clone()];
-                }
-            }
-            else {
-                // If multiple variables, only handle perfect squares...
-                a = this.monomByDegree(2, letter);
-                b = this.monomByDegree(1, letter);
-                c = this.monomByDegree(0, letter);
-                if (a.isLiteralSquare() && c.isLiteralSquare()) {
-                    // Check the middle item is same as...
-                    if (b.clone().pow(2).isSameAs(a.clone().multiply(c))) {
-                        // Determine if the coefficient values matches.
-                        // Search 4 values (r, s, t, u) that matches:
-                        // (r X + s Y)(t X + u Y) = rt X^2 + (ru + st) XY + su Y^2
-                        let xPolynom = new Polynom('x', a.coefficient, b.coefficient, c.coefficient);
-                        let xFactors = xPolynom._factorize2ndDegree('x');
-                        let factors = [], xyzPolynom;
-                        if (xFactors.length >= 2) {
-                            for (let p of xFactors) {
-                                if (p.degree().isZero()) {
-                                    factors.push(p.clone());
-                                }
-                                else {
-                                    xyzPolynom = p.clone();
-                                    xyzPolynom.monoms[0].literal = a.literalSqrt;
-                                    xyzPolynom.monoms[1].literal = c.literalSqrt;
-                                    factors.push(xyzPolynom.clone());
-                                }
-                            }
-                            return factors;
-                        }
-                    }
-                }
-                return [this.clone()];
-            }
-        };
-        this._factorizeByGroups = () => {
-            // TODO: Factorize by groups.
-            return [];
-        };
-        this._monoms = [];
-        this._factors = [];
-        this.mark_as_dirty();
-        if (polynomString !== undefined) {
-            this.parse(polynomString, ...values);
-        }
-        return this;
-    }
-    // ------------------------------------------
-    get dirty_factors() {
-        return this._dirty_factors;
-    }
-    set dirty_factors(value) {
-        this._dirty_factors = value;
-    }
-    get dirty_zeroes() {
-        return this._dirty_zeroes;
-    }
-    set dirty_zeroes(value) {
-        this._dirty_zeroes = value;
-    }
-    get euclidianCache() {
-        return this._euclidianCache;
-    }
-    set euclidianCache(value) {
-        this._euclidianCache = value;
-    }
-    get factors() {
-        return this.factorize();
-    }
-    set factors(value) {
-        this.mark_as_dirty();
-        this._factors = value;
-    }
-    // ------------------------------------------
-    get monoms() {
-        return this._monoms;
-    }
-    set monoms(M) {
-        this._monoms = M;
-    }
-    get texString() {
-        return this._texString;
-    }
-    get zeroes() {
-        return this.getZeroes();
-    }
-    get texFactors() {
-        this.factorize();
-        if (this.factors.length <= 1) {
-            return this.tex;
-        }
-        // Build an array of texFactors with the number of similar items.
-        let factorsCount = {};
-        for (let f of this.factors) {
-            if (factorsCount[f.tex] !== undefined) {
-                factorsCount[f.tex].degree++;
-            }
-            else {
-                factorsCount[f.tex] = {
-                    degree: 1,
-                    factor: f
-                };
-            }
-        }
-        // First round to put the 'monom' first
-        let simpleFactor = new Polynom().one();
-        for (let item of Object.values(factorsCount).filter(item => item.factor.monoms.length === 1)) {
-            simpleFactor.multiply(item.factor);
-        }
-        let tex = simpleFactor.isOne() ? '' : simpleFactor.tex;
-        // Loop through all factors that contains at least 2 monoms.
-        for (let item of Object.values(factorsCount).filter(item => item.factor.monoms.length > 1)) {
-            if (item.factor.length > 1) {
-                tex += `\\left( ${item.factor.tex} \\right)${item.degree > 1 ? '^{ ' + item.degree + ' }' : ''}`;
-            }
-        }
-        return tex;
-    }
-    get displayFactors() {
-        this.factorize();
-        if (this.factors.length <= 1) {
-            return this.display;
-        }
-        // Build an array of texFactors with the number of similar items.
-        let factorsCount = {};
-        for (let f of this.factors) {
-            if (factorsCount[f.display] !== undefined) {
-                factorsCount[f.display].degree++;
-            }
-            else {
-                factorsCount[f.display] = {
-                    degree: 1,
-                    factor: f
-                };
-            }
-        }
-        // First round to put the 'monom' first
-        let simpleFactor = new Polynom().one();
-        for (let item of Object.values(factorsCount).filter(item => item.factor.monoms.length === 1)) {
-            simpleFactor.multiply(item.factor);
-        }
-        let display = simpleFactor.isOne() ? '' : simpleFactor.display;
-        // Loop through all factors that contains at least 2 monoms.
-        for (let item of Object.values(factorsCount).filter(item => item.factor.monoms.length > 1)) {
-            if (item.factor.length > 1) {
-                display += `(${item.factor.display})${item.degree > 1 ? '^(' + item.degree + ')' : ''}`;
-            }
-        }
-        return display;
-    }
-    get length() {
-        // TODO: Must reduce the monoms list to remove the zero coefficient.
-        return this._monoms.length;
-    }
-    get display() {
-        return this.genDisplay();
-    }
-    get raw() {
-        return this._rawString;
-    }
-    get tex() {
-        return this.genDisplay('tex');
-    }
-    get isMultiVariable() {
-        const B = false;
-        for (const m of this._monoms) {
-            if (m.variables.length > 1) {
-                return true;
-            }
-        }
-        return B;
-    }
-    get variables() {
-        let V = [];
-        for (const m of this._monoms) {
-            V = V.concat(m.variables);
-        }
-        // Remove duplicates.
-        V = [...new Set(V)];
-        V.sort();
-        return V;
-    }
-    get numberOfVars() {
-        return this.variables.length;
-    }
-    get plotFunction() {
-        return this.genDisplay('tex', false, false, true);
-    }
-    isZero() {
-        return (this._monoms.length === 1 && this._monoms[0].coefficient.isZero()) || this._monoms.length === 0;
-    }
-    isOne() {
-        return this._monoms.length === 1 && this._monoms[0].coefficient.isOne();
-    }
-    _parseString(inputStr, ...values) {
-        if (values === undefined || values.length === 0) {
-            inputStr = '' + inputStr;
-            this._rawString = inputStr.trim().replaceAll(' ', '');
-            // Parse the polynom using the shutting yard algorithm
-            if (inputStr !== '' && !isNaN(Number(inputStr))) {
-                this.empty();
-                // It's a simple number.
-                let m = new monom_1.Monom(inputStr);
-                // m.coefficient = new Fraction(inputStr);
-                // m.literalStr = '';
-                this.add(m);
-                return this;
-            }
-            // Parse the string.
-            return this.shutingYardToReducedPolynom(inputStr);
-        }
-        else if (/^[a-z]/.test(inputStr)) {
-            // We assume the inputStr contains only letters.
-            this.empty();
-            let fractions = values.map(x => new fraction_1.Fraction(x));
-            // Multiple setLetter version
-            if (inputStr.length > 1) {
-                // TODO: check that the number of values given correspond to the letters (+1 eventually)
-                let letters = inputStr.split(''), i = 0;
-                for (let F of fractions) {
-                    let m = new monom_1.Monom();
-                    m.coefficient = F.clone();
-                    m.literalStr = letters[i] || '';
-                    this.add(m);
-                    i++;
-                }
-            }
-            // Single setLetter version
-            else {
-                let n = fractions.length - 1;
-                for (let F of fractions) {
-                    let m = new monom_1.Monom();
-                    m.coefficient = F.clone();
-                    m.literalStr = `${inputStr}^${n}`;
-                    this.add(m);
-                    n--;
-                }
-            }
-            return this;
-        }
-        else {
-            return this.zero();
-        }
-    }
-}
-exports.Polynom = Polynom;
-//# sourceMappingURL=polynom.js.map