pimath 0.2.14 → 0.2.15

package/src/algebra/polynom.ts

@@ -1,1229 +1,1233 @@
-/**
- * Polynom module contains everything necessary to handle polynoms.*
- */
-import {ShutingYard, ShutingyardType, type Token} from "piexpression"
-import {InvalidArgumentError, MathError, ParseError} from "../errors"
-import type {
-    IAlgebra,
-    IAnalyse,
-    IExpression,
-    InputAlgebra,
-    InputValue,
-    IPiMathObject,
-    literalType,
-    TABLE_OF_SIGNS,
-    TABLE_OF_SIGNS_VALUES
-} from "../pimath.interface"
-import {Fraction} from "../coefficients"
-import {Numeric} from '../numeric'
-import {EquationSolver} from './equationSolver'
-import {Monom} from './monom'
-import {replace_in_array} from "../helpers"
-import {operation_pow} from "./operations"
-import {Solution} from "../analyze/solution"
-
-
-export type PolynomParsingType = InputValue<Polynom> | Monom
-
-export interface IEuclidean {
-    quotient: Polynom,
-    reminder: Polynom
-}
-
-/**
- * Polynom class can handle polynoms, reorder, resolve, ...
- * ```
- * let P = new Polynom('3x-4')
- * ```
- */
-export class Polynom implements IPiMathObject<Polynom>,
-    IExpression<Polynom>,
-    IAnalyse<Polynom>,
-    IAlgebra<Polynom> {
-
-    #defaultVariable = 'x'
-    #factors: Polynom[]
-    #monoms: Monom[]
-    #roots: Solution[]
-    #rootsCache = false
-
-    constructor(value: InputValue<Fraction>)
-    constructor(value: string)
-    constructor(value: Monom)
-    constructor(value: Polynom)
-    constructor(...values: InputValue<Fraction>[])
-    constructor(...values: InputAlgebra<Polynom>[])
-    constructor(polynomString?: InputAlgebra<Polynom>, ...values: InputAlgebra<Fraction>[]) {
-        this.#monoms = []
-        this.#factors = []
-        this.#roots = []
-
-        if (polynomString !== undefined) {
-            this.parse(polynomString, ...values)
-        }
-        return this
-    }
-
-
-    /**
-     * Parse a string to a polynom.
-     * @param inputStr
-     * @param values
-     */
-    public parse(inputStr: PolynomParsingType, ...values: InputAlgebra<Monom>[]): this {
-        // Reset the main variables.
-        this.#monoms = []
-        this.#factors = []
-        this.#invalidateCache()
-
-        if (typeof inputStr === 'string') {
-            return this.#parseString(inputStr, ...values as InputValue<Fraction>[])
-        } else if (
-            (typeof inputStr === 'number' || inputStr instanceof Fraction || inputStr instanceof Monom)
-            && (values.length === 0)
-        ) {
-            this.#monoms.push(new Monom(inputStr as Monom))
-        } else if (inputStr instanceof Monom && values.length > 0) {
-            this.#monoms.push(new Monom(inputStr))
-            values.forEach(m => {
-                this.#monoms.push(new Monom(m as Monom))
-            })
-        } else if (inputStr instanceof Polynom) {
-            for (const m of inputStr.monoms) {
-                this.#monoms.push(m.clone())
-            }
-        }
-
-
-        return this
-    }
-
-    /**
-     * Clone the polynom
-     */
-    public clone(): Polynom {
-        const P = new Polynom()
-        const M: Monom[] = []
-        P.#defaultVariable = this.#defaultVariable
-
-        for (const m of this.#monoms) {
-            M.push(m.clone())
-        }
-
-        P.monoms = M
-
-        return P
-    }
-
-    public get tex(): string {
-        return this.#genDisplay('tex')
-    }
-
-    public get display(): string {
-        return this.#genDisplay()
-    }
-
-    static xMultiply(...polynoms: InputValue<Polynom>[]): Polynom {
-        const result = new Polynom().one()
-
-        polynoms.forEach(P => {
-            result.multiply(P)
-        })
-
-        return result
-    }
-
-    public add(...values: InputAlgebra<Polynom>[]): this {
-
-        for (const value of values) {
-            if (value instanceof Polynom) {
-                this.#monoms = this.#monoms.concat(value.monoms.map(m => m.clone()))
-            } else if (value instanceof Monom) {
-                this.#monoms.push(value.clone())
-            } else if (typeof value === "number" && Number.isSafeInteger(value)) {
-                this.#monoms.push(new Monom(value.toString()))
-            } else {
-                this.#monoms.push(new Monom(value))
-            }
-        }
-
-
-        return this.reduce()
-    }
-
-    public commonMonom(): Monom {
-        const M = new Monom().one()
-        const numerator: number = this.gcdNumerator()
-        const denominator: number = this.gcdDenominator()
-
-        M.coefficient = new Fraction(numerator, denominator)
-        for (const L of this.variables) {
-            // Initialize the setLetter with the max degree
-            M.setLetter(L, this.degree(L))
-            for (const m of this.#monoms) {
-                M.setLetter(L, Fraction.min(m.degree(L), M.degree(L)))
-                if (M.degree(L).isZero()) {
-                    break
-                }
-
-            }
-        }
-        return M
-    }
-
-    public degree(letter?: string): Fraction {
-        let d: Fraction = new Fraction().zero()
-        for (const m of this.#monoms) {
-            d = Fraction.max(m.degree(letter).value, d)
-        }
-
-        return d
-    }
-
-    public derivative(letter?: string): Polynom {
-        const dP = new Polynom()
-
-        for (const m of this.#monoms) {
-            dP.add(m.derivative(letter))
-        }
-
-        return dP.reduce()
-    }
-
-    public divide(value: InputAlgebra<Polynom>): this {
-
-        if (value instanceof Fraction) {
-            return this.#divideByFraction(value)
-        } else if (typeof value === 'number' && Number.isSafeInteger(value)) {
-            return this.#divideByInteger(value)
-        } else if (value instanceof 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 {
-                const {quotient, reminder} = this.euclidean(value)
-                if (reminder.isZero()) {
-                    this.#monoms = quotient.monoms
-                    this.#invalidateCache()
-                    return this
-                }
-            }
-        } else if (typeof value === 'string') {
-            return this.divide(new Polynom(value))
-        }
-
-        throw new MathError(`Cannot divide by ${value as unknown as string}`)
-    }
-
-    public empty(): this {
-        this.#monoms = []
-        this.#invalidateCache()
-        return this
-    }
-
-    /**
-     * Divide the current polynom by another polynom.
-     * @param P
-     * returns {quotient: Polynom, reminder: Polynom}
-     */
-    public euclidean(P: Polynom): IEuclidean {
-        const letter: string | undefined = P.variables[0]
-        const quotient: Polynom = new Polynom().zero()
-        const reminder: Polynom = this.clone().reorder(letter)
-
-        // There is no variable - means it's a number
-        if (P.variables.length === 0) {
-            const q = this.clone().divide(P)
-
-            return {
-                quotient: q.reduce(),
-                reminder: new Polynom().zero()
-            }
-        }
-
-        if (!this.degree(letter).isNatural() || !P.degree(letter).isNatural()) {
-            throw new MathError('Euclidean division requires integer degrees')
-        }
-
-        // Get at least a letter
-        const maxMP: Monom = P.monomByDegree(undefined, letter)
-        const degreeP: Fraction = P.degree(letter)
-
-        let newM: Monom
-
-        // Make the Euclidean division of the two polynoms.
-        let MaxIteration = this.degree(letter).value - degreeP.value + 1
-
-        while (reminder.degree(letter).isGeq(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()) {
-                continue
-            }
-
-            // Get the new quotient and reminder.
-            quotient.add(newM)
-            reminder.subtract(P.clone().multiply(newM)).reduce()
-
-            // Check if the reminder is zero.
-            if (newM.degree(letter).isZero()) {
-                break
-            }
-        }
-
-        quotient.reduce()
-        reminder.reduce()
-        return {quotient, reminder}
-    }
-
-    public evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric: true): number
-    public evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric?: false): Fraction
-    public evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric?: boolean): Fraction | number
-    public evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric?: boolean): Fraction | number {
-        // Return the numeric value without using Fraction
-        if (asNumeric) {
-            return this.#evaluateAsNumeric(values)
-        }
-
-        // Build the evaluated fraction
-        const r = new Fraction().zero()
-        this.#monoms.forEach(monom => {
-            r.add(monom.evaluate(values, asNumeric))
-        })
-
-        return r
-    }
-
-    // -------------------------------------
-    /**
-     * Factorize a polynom and store the best results in factors.
-     * @param _letter
-     * TODO: Handle other letter than 'x'.
-     */
-    public factorize(_letter?: string): Polynom[] {
-        this.#factors = []
-
-        // There is only one monom - it's already considered as factor.
-        if (this.monoms.length === 1) return [this.clone()]
-
-        let P = this.clone().reorder()
-
-        // Extract the common monom
-        // 2x^3+6x^2 => 2x^2
-        const M = P.commonMonom()
-
-        // If the polynom starts with a negative monom, factorize it.
-        if (P.monomByDegree().coefficient.isStrictlyNegative()) M.opposite()
-
-        if (!M.isOne()) {
-            this.#factors.push(new Polynom(M))
-            P = P.euclidean(this.#factors[0]).quotient
-        }
-
-        const solutions = new EquationSolver(P).solve()
-
-        if (solutions.length === 0) {
-            if (this.#factors.length === 0) {
-                // No common monom was extracted: the whole polynomial is irreducible
-                this.#factors = [this.clone()]
-            } else {
-                // Common monom was extracted: P is the irreducible remaining part
-                this.#factors.push(P)
-            }
-            return this.#factors
-        }
-
-        solutions.forEach(sol => {
-            if (sol.exact && sol.root.isZero()) {
-                for (let i = 0; i < sol.count; i++) {
-                    if (sol.fraction.isRational()) {
-                        this.#factors.push(new Polynom().fromCoefficients(sol.fraction.denominator, -sol.fraction.numerator))
-                    } else {
-                        this.#factors.push(new Polynom().fromCoefficients(1, sol.fraction.clone().opposite()))
-                    }
-                }
-            }
-        })
-
-        // Check if we have all factors.
-        const fDegrees = this.#factors
-            .map(f => f.degree().value)
-            .reduce((a, b) => a + b, 0)
-
-        if (fDegrees < this.degree().value) {
-            // missing polynom.
-            const fPolynom = Polynom.xMultiply(...this.#factors)
-            this.#factors.push(this.clone().divide(fPolynom))
-        }
-
-        return this.#factors
-    }
-
-    get factors(): Polynom[] {
-        if (this.#factors.length === 0 && !this.isZero()) {
-            return this.factorize()
-        }
-
-        return this.#factors
-    }
-
-    public fromCoefficients(...values: InputValue<Fraction>[]): this {
-
-        this.#monoms = []
-        const letter = this.#defaultVariable ?? 'x'
-        values.reverse().forEach((coeff, index) => {
-            const monom = new Monom()
-            monom.coefficient = new Fraction(coeff)
-            monom.setLetter(letter, index)
-
-            this.#monoms.push(monom)
-        })
-
-        this.#invalidateCache()
-        return this.reorder()
-    }
-
-    public gcdDenominator(): number {
-        return Numeric.gcd(...this.getDenominators())
-    }
-
-    public gcdNumerator(): number {
-        return Numeric.gcd(...this.getNumerators())
-    }
-
-    public getCoefficients(): Fraction[] {
-        if (!this.degree().isNatural()) {
-            throw new MathError('getCoefficients() requires a polynomial with integer degrees')
-        }
-
-        // Assume there is only one letter.
-        const orderedPolynom = this.clone().reorder()
-
-        const length = this.degree().value + 1
-        const coeffs = Array.from({length}, () => new Fraction(0))
-
-        orderedPolynom.monoms.forEach(monom => {
-            const index = length - monom.degree().value - 1
-            coeffs[index] = monom.coefficient.clone()
-        })
-
-        return coeffs
-    }
-
-    // Next functions are used for for commonMonom, which is used in the factorize method.
-    public getDenominators(): number[] {
-        const denominators: number[] = []
-        for (const m of this.#monoms) {
-            denominators.push(m.coefficient.denominator)
-        }
-
-        return denominators
-    }
-
-    public getNumerators(): number[] {
-        const numerators: number[] = []
-        for (const m of this.#monoms) {
-            numerators.push(m.coefficient.numerator)
-        }
-
-        return numerators
-    }
-
-    public getZeroes(): Solution[] {
-        if (this.degree().isZero()) {
-            return []
-        }
-
-        this.roots = new EquationSolver(this.clone()).solve()
-        return this.roots
-    }
-
-    public hasVariable(letter: string): boolean {
-        return this.variables.includes(letter)
-    }
-
-    public integrate(a: InputValue<Fraction>, b: InputValue<Fraction>, letter = 'x'): Fraction {
-        const primitive = this.primitive(letter)
-
-        const valuesA: literalType<Fraction> = {}
-        const valuesB: literalType<Fraction> = {}
-
-        valuesA[letter] = new Fraction(a)
-        valuesB[letter] = new Fraction(b)
-
-        return (primitive.evaluate(valuesB)).subtract(primitive.evaluate(valuesA))
-    }
-
-    public inverse(): Polynom | undefined {
-        return undefined
-    }
-
-    public isDeveloped(polynomString: string): boolean {
-        // Start by removing the parenthesis after a "power"
-        const pString = polynomString.replaceAll(/\^\(([-0-9/]+)\)/g, '$1')
-
-        // There is at least one parenthesis - it is not developed.
-        if (pString.includes('(') || pString.includes(')')) {
-            return false
-        }
-
-
-        // Build the polynom. A malformed string throws (ParseError) instead of
-        // being silently treated as "not developed".
-        const P = new Polynom(polynomString)
-
-        // 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
-    }
-
-    public isDividableBy(div: Polynom): boolean {
-        // Quick evaluation.
-        if (div.degree().isOne()) {
-            const zero = div.getZeroes()[0]
-
-            if (zero.exact) {
-                return (this.evaluate(zero.fraction)).isZero()
-            } else {
-                return false
-            }
-
-        } else {
-            const {reminder} = this.euclidean(div)
-            return reminder.isZero()
-        }
-    }
-
-    public isEqual(P: Polynom): boolean {
-        return this.#compare(P, '=')
-    }
-
-    public get isMultiVariable(): boolean {
-        // Determine if a monom has more than one variable.
-        return this.#monoms.some(m => m.variables.length > 1)
-    }
-
-    public isOne(): boolean {
-        return this.#monoms.length === 1 && this.#monoms[0].coefficient.isOne() && this.degree().isZero()
-    }
-
-    public isOppositeAt(P: Polynom): boolean {
-        return this.#compare(P.clone().opposite(), '=')
-    }
-
-    public isSameAs(P: Polynom): boolean {
-        return this.#compare(P, 'same')
-    }
-
-    public isZero(): boolean {
-        return (this.#monoms.length === 1 && this.#monoms[0].coefficient.isZero()) || this.#monoms.length === 0
-    }
-
-    public lcmDenominator(): number {
-        return Numeric.lcm(...this.getDenominators())
-    }
-
-    public lcmNumerator(): number {
-        return Numeric.lcm(...this.getNumerators())
-    }
-
-    public get length() {
-        return this.#monoms.length
-    }
-
-    public limitTo(value: InputValue<Fraction>, letter?: string): Fraction {
-        const f = new Fraction(value)
-
-        // Finite value: evaluate directly
-        if (f.isFinite()) {
-            const l = letter ?? this.variables[0] ?? 'x'
-            return this.evaluate({[l]: f})
-        }
-
-        const M = this.monomByDegree(undefined, letter)
-        const sign = M.coefficient.sign()
-        const degree = M.degree(letter)
-
-        // Constant polynomial
-        if (degree.isZero()) {
-            return M.coefficient.clone()
-        }
-
-        if (!degree.isStrictlyPositive()) {
-            return new Fraction().zero()
-        }
-
-        // Limit at +∞: determined by the leading coefficient sign
-        if (f.isPositive()) {
-            return sign === 1
-                ? new Fraction().infinite()
-                : new Fraction().infinite().opposite()
-        }
-
-        // Limit at -∞: accounts for the parity of the degree
-        const degreeIsEven = degree.value % 2 === 0
-        const limitSign = degreeIsEven ? sign : -sign
-        return limitSign === 1
-            ? new Fraction().infinite()
-            : new Fraction().infinite().opposite()
-    }
-
-    public monomByDegree(degree?: Fraction | number, letter?: string): Monom {
-        // return the highest degree monom.
-        if (degree === undefined) {
-            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().zero()
-    }
-
-    // Used in LinearSystem.tex
-    public monomByLetter(letter: string): Monom {
-        const M = this.clone().reduce()
-        for (const m of M.#monoms) {
-            if (m.hasVariable(letter)) {
-                return m.clone()
-            }
-        }
-
-        return new Monom().zero()
-    }
-
-    // ------------------------------------------
-    public get monoms() {
-        return this.#monoms
-    }
-
-    public set monoms(M: Monom[]) {
-        this.#monoms = M
-        this.#invalidateCache()
-    }
-
-    public monomsByDegree(degree?: number | Fraction, letter?: string): Monom[] {
-        // return the highest degree monom.
-        if (degree === undefined) {
-            return this.monomsByDegree(this.degree(letter), letter)
-        }
-
-        // Reduce the polynom.
-        const Ms: Monom[] = []
-
-        const M = this.clone().reduce()
-        for (const m of M.#monoms) {
-            if (m.degree(letter).isEqual(degree)) {
-                Ms.push(m.clone())
-            }
-        }
-
-        return Ms
-    }
-
-    public multiply(value: InputAlgebra<Polynom>): this {
-
-        if (value instanceof Polynom) {
-            return this.#multiplyByPolynom(value)
-        }
-
-        if (value instanceof Fraction) {
-            return this.#multiplyByFraction(value)
-        }
-
-        if (value instanceof Monom) {
-            return this.#multiplyByMonom(value)
-        }
-
-        if (Number.isSafeInteger(value) && typeof value === 'number') {
-            return this.#multiplyByInteger(value)
-        }
-
-        if (typeof value === 'string') {
-            try {
-                const k = new Fraction(value)
-                return this.#multiplyByFraction(k)
-            } catch (e) {
-                throw new MathError('Cannot multiply by this value.', {cause: e})
-            }
-        }
-
-        // Something went wrong...
-        throw new MathError(`Cannot multiply by this value: ${value as unknown as string}`)
-    }
-
-    public get numberOfVars(): number {
-        return this.variables.length
-    }
-
-    public one(): this {
-        this.#monoms = []
-        this.#monoms.push(new Monom().one())
-        this.#invalidateCache()
-        return this
-    }
-
-    // ------------------------------------------
-    public opposite(): this {
-        this.#monoms = this.#monoms.map(m => m.opposite())
-        this.#invalidateCache()
-        return this
-    }
-
-    public get plotFunction(): string {
-        return this.#genDisplay('tex', false, false, true)
-    }
-
-    public pow(nb: number): Polynom {
-        return operation_pow(this as Polynom, nb).reduce()
-    }
-
-    public primitive(letter?: string): Polynom {
-        const dP = new Polynom()
-
-        for (const m of this.#monoms) {
-            dP.add(m.primitive(letter))
-        }
-
-        return dP
-    }
-
-    public reduce(): this {
-        // Reduce the polynom
-
-        // 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().zero()
-                    }
-
-                    j--
-                }
-            }
-
-            i++
-        }
-
-        // Remove all null monoms
-        this.#monoms = this.#monoms.filter((m) => {
-            return !m.coefficient.isZero()
-        })
-
-        // Reduce all monoms coefficient.
-        for (const m of this.#monoms) {
-            m.coefficient.reduce()
-        }
-
-        if (this.length === 0) {
-            return this.zero()
-        }
-
-        this.#invalidateCache()
-        return this.reorder()
-    }
-
-    public reorder(letter = 'x', revert = false): this {
-        const otherLetters = this.variables.filter(x => x !== letter)
-        this.#monoms.sort(function (a, b) {
-            const da = a.degree(letter).value
-            const 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 reverted in that case !
-            if (otherLetters.length > 0) {
-                for (const L of otherLetters) {
-                    const da = a.degree(L).value
-                    const db = b.degree(L).value
-
-                    // Values are different
-                    if (da !== db) {
-                        return revert ? da - db : db - da
-                    }
-                }
-            }
-
-
-            return 0
-        })
-
-        return this
-    }
-
-    /**
-     * Replace a variable (letter) by a polynom.
-     * @param letter
-     * @param P
-     */
-    public replaceBy(letter: string, P: Polynom): this {
-        let pow: Fraction
-        const resultPolynom: Polynom = new Polynom().zero()
-
-        for (const m of this.monoms) {
-            if (!m.hasVariable(letter) || m.literal[letter].isZero()) {
-                resultPolynom.add(m.clone())
-            } else {
-                // We have found a variable to replace.
-
-                // Get the power.
-                pow = m.literal[letter].clone()
-
-                // Remove the variable from the monom
-                m.removeVariable(letter)
-
-                // Add the new monom to the result polynom
-                if (pow.isStrictlyNegative()) {
-                    throw new MathError(`Cannot replace variable "${letter}" with negative power in a Polynom`)
-                }
-                resultPolynom.add(P.clone().pow(pow.numerator).multiply(m))
-            }
-        }
-
-
-        // Reduce the monoms
-        this.#monoms = resultPolynom.reduce().monoms
-        this.#invalidateCache()
-        return this
-    }
-
-    // ------------------------------------------
-
-    public root(): Polynom {
-        throw new MathError('Cannot take the root from a polynom')
-    }
-
-    get roots(): Solution[] {
-        return this.#rootsCache ? this.#roots : this.getZeroes()
-    }
-
-    set roots(value: Solution[]) {
-        this.#rootsCache = true
-        this.#roots = value
-    }
-
-    public setVariable(value: string): this {
-        this.#defaultVariable = value
-
-        return this
-    }
-
-    public sqrt(): Polynom {
-        throw new MathError('Cannot take the square root from a polynom')
-    }
-
-    public subtract(...values: InputAlgebra<Polynom>[]): this {
-        for (const value of values) {
-            if (value instanceof Polynom) {
-                this.add(value.clone().opposite())
-            } else if (value instanceof Monom) {
-                this.#monoms.push(value.clone().opposite())
-            } else {
-                this.#monoms.push(new Monom(value).opposite())
-            }
-        }
-
-
-        return this.reduce()
-    }
-
-    public tableOfSigns(): TABLE_OF_SIGNS {
-        // returns ['+-', 'd|t|z', '+-']...
-
-        // global roots from eventually Polyfactor. Allows to add "extra column".
-        const roots: Solution[] = this.roots
-
-        // Build the table os sign length and default values
-        // The signs looks like: ['+', 't', '+', 't', '+', 't', '+']
-        let signs: TABLE_OF_SIGNS_VALUES[] = new Array(2 * roots.length + 1)
-            .fill('')
-            .map((_x, index) => {
-                return index % 2 === 0 ? '' : 'z'
-            })
-
-
-        if (signs.length === 1) {
-            // The polynom is a constant or has not roots
-            const [a] = this.getCoefficients().map(x => x.value)
-            signs = replace_in_array(signs, '', a > 0 ? '+' : '-')
-        } else if (this.degree().isOne()) {
-            // First degree: ax+b
-            const [a] = this.getCoefficients().map(x => x.value)
-
-            // Get the index of the zero.
-            signs[0] = a > 0 ? '-' : '+'
-            signs[1] = 'z'
-            signs[2] = a > 0 ? '+' : '-'
-        } else {
-            const testingRoots = [
-                roots[0].value - 1,
-                ...roots.map((_root, index) => {
-                    return index === roots.length - 1 ?
-                        roots[index].value + 1 :
-                        (roots[index].value + roots[index + 1].value) / 2
-                })
-            ]
-
-            testingRoots.forEach((test, index) => {
-                const sign = this.evaluate({[this.variables[0] ?? 'x']: test}, true)
-                signs[index * 2] = sign > 0 ? '+' : '-'
-            })
-        }
-
-        return {roots, signs}
-    }
-
-    public get value(): number | undefined {
-        if (this.degree().isZero()) {
-            return this.monoms[0]?.coefficient.value ?? 0
-        }
-
-        return undefined
-    }
-
-    public get variables(): string[] {
-        return [...new Set(this.#monoms.flatMap(m => m.variables))].sort()
-    }
-
-    /**
-     * Set the polynom to zero.
-     * @returns {this}
-     */
-    public zero(): this {
-        this.#monoms = []
-        this.#monoms.push(new Monom().zero())
-        this.#invalidateCache()
-        return this
-    }
-
-    public get zeroes(): Solution[] {
-        return this.getZeroes()
-    }
-
-    #compare(P: Polynom, sign?: string): boolean {
-        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().isEqual(cP2.degree())) {
-                    return false
-                }
-
-                // Check if the coefficients are the isSame.
-                return cP1.monoms
-                    .every((m1, index) => m1.isEqual(cP2.monoms[index]))
-
-            case 'same':
-                // They must have the same length and the same degree
-                if (cP1.length !== cP2.length || !cP1.degree().isEqual(cP2.degree())) {
-                    return false
-                }
-
-                return cP1.monoms
-                    .every((m1, index) => m1.isSameAs(cP2.monoms[index]))
-
-            default:
-                return false
-        }
-    }
-
-    #divideByFraction(F: Fraction): this {
-        for (const m of this.#monoms) {
-            m.coefficient.divide(F)
-        }
-
-        this.#invalidateCache()
-        return this
-    }
-
-    #divideByInteger(nb: number): this {
-        const nbF = new Fraction(nb)
-        for (const m of this.#monoms) {
-            m.coefficient.divide(nbF)
-        }
-
-        this.#invalidateCache()
-        return this
-    }
-
-    #evaluateAsNumeric(values: literalType<number | Fraction> | InputValue<Fraction>): number {
-        let r = 0
-        this.#monoms.forEach(monom => {
-            r += monom.evaluate(values, true) as number
-        })
-
-        return r
-    }
-
-    #genDisplay(output?: string, forceSign?: boolean, wrapParentheses?: boolean, withAllMultiplicationSign?: boolean): string {
-        let P = ''
-
-        for (const k of this.#monoms) {
-            if (k.coefficient.value === 0) {
-                continue
-            }
-
-            // The monom to be displayed
-            let m
-            if (withAllMultiplicationSign) {
-                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
-    }
-
-    #invalidateCache(): void {
-        this.#rootsCache = false
-        this.#factors = []
-    }
-
-    #multiplyByFraction(F: Fraction): this {
-        for (const m of this.#monoms) {
-            m.coefficient.multiply(F)
-        }
-
-        return this.reduce()
-    }
-
-    #multiplyByInteger(nb: number): this {
-        return this.#multiplyByFraction(new Fraction(nb))
-    }
-
-    #multiplyByMonom(M: Monom): this {
-        for (const m of this.#monoms) {
-            m.multiply(M)
-        }
-
-        return this.reduce()
-    }
-
-    #multiplyByPolynom(P: Polynom): this {
-        const M: Monom[] = []
-        for (const m1 of this.#monoms) {
-            for (const m2 of P.monoms) {
-                M.push(Monom.xMultiply(m1, m2))
-            }
-        }
-
-        this.#monoms = M
-        return this.reduce()
-    }
-
-    #parseString(inputStr: string, ...values: InputValue<Fraction>[]): this {
-        if (values.length === 0) {
-            // Parse the polynom using the shutting yard algorithm
-            if (inputStr !== '' && !isNaN(Number(inputStr))) {
-                this.empty()
-                // It's a simple number.
-                const m = new Monom(Number(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()
-
-            const fractions = values.map(x => new Fraction(x))
-
-            // Multiple setLetter version
-            if (inputStr.length > 1) {
-                const letters = inputStr.split('')
-
-                if (fractions.length > letters.length + 1) {
-                    throw new InvalidArgumentError(`Too many values: ${letters.length} letters but ${fractions.length} values provided`)
-                }
-
-                let i = 0
-
-                for (const F of fractions) {
-                    const m = new Monom()
-                    m.coefficient = F.clone()
-                    m.literalStr = letters[i] ?? ''
-                    this.add(m)
-                    i++
-                }
-            }
-            // Single setLetter version
-            else {
-                let n = fractions.length - 1
-                for (const F of fractions) {
-                    const m = new Monom()
-                    m.coefficient = F.clone()
-                    m.literalStr = `${inputStr}^${n}`
-                    this.add(m)
-                    n--
-                }
-            }
-            return this
-        } else {
-            return this.zero()
-        }
-
-    }
-
-    #shutingYardAddToken(stack: Polynom[], element: Token): void {
-        switch (element.tokenType) {
-            case ShutingyardType.COEFFICIENT:
-                stack.push(new Polynom(element.token))
-                break
-
-            case ShutingyardType.VARIABLE:
-                stack.push(new Polynom().add(new Monom(element.token)))
-                break
-
-            case ShutingyardType.CONSTANT:
-                throw new ParseError('Unsupported CONSTANT token in Polynom parser')
-
-            case ShutingyardType.OPERATION:
-                if (stack.length >= 2) {
-                    const b = stack.pop()
-                    const a = stack.pop()
-
-                    // Check if the polynoms are not undefined.
-                    if (a === undefined || b === undefined) {
-                        throw new ParseError('Unexpected undefined operand in Polynom parser stack')
-                    }
-
-                    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()) {
-                            throw new MathError('Cannot divide a Polynom by another Polynom of degree > 0')
-                        } else {
-                            // a.divide(b.monoms[0].coefficient)
-                            stack.push(a.divide(b.monoms[0].coefficient))
-                        }
-                    } else if (element.token === '^') {
-                        if (b.degree().isStrictlyPositive()) {
-                            throw new MathError('Cannot elevate a polynom with another polynom !')
-                        } else if (b.monoms[0].coefficient.isNatural())
-                            // Natural (positive) 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 (const letter in a.monoms[0].literal) {
-                                    a.monoms[0].literal[letter].multiply(b.monoms[0].coefficient)
-                                }
-
-                                stack.push(a)
-                            } else {
-                                throw new MathError('Cannot raise a multi-monom Polynom to a fractional power')
-                            }
-                        }
-                    }
-
-                } else if (element.token === '-') {
-                    const a = stack.pop()
-                    if (a) {
-                        stack.push(a.opposite())
-                    }
-                } else {
-                    throw new ParseError("Error parsing the polynom")
-                }
-
-
-                break
-
-            case ShutingyardType.MONOM:
-                // Should never appear.
-                throw new ParseError('Unexpected MONOM token in polynom parser')
-
-            case ShutingyardType.FUNCTION:
-                // Should never appear.
-                throw new ParseError(`Unsupported function token "${element.token}" in polynom parser`)
-        }
-
-
-    }
-
-    /**
-     * Main parse using a shutting yard class
-     * @param inputStr
-     */
-    #shutingYardToReducedPolynom(inputStr: string): this {
-        // Get the RPN array of the current expression
-        let SY: ShutingYard
-        try {
-            SY = new ShutingYard().parse(inputStr)
-        } catch (e) {
-            throw new ParseError(`Cannot parse "${inputStr}" as a Polynom`, {cause: e})
-        }
-        const rpn: { token: string, tokenType: ShutingyardType }[] = SY.rpn
-
-        // New version for reducing shuting yard.
-        this.zero()
-
-        const stack: Polynom[] = []
-
-        // Loop through the each element of the RPN
-        for (const element of rpn) {
-            this.#shutingYardAddToken(stack, element)
-        }
-
-
-        if (stack.length === 1) {
-            this.add(stack[0])
-        }
-
-
-        return this.reorder()
-    }
-
-
-}
+/**
+ * Polynom module contains everything necessary to handle polynoms.*
+ */
+import {ShutingYard, ShutingyardType, type Token} from "piexpression"
+import {InvalidArgumentError, MathError, NotImplementedError, ParseError} from "../errors"
+import type {
+    IAlgebra,
+    IAnalyse,
+    IExpression,
+    InputAlgebra,
+    InputValue,
+    IPiMathObject,
+    literalType,
+    TABLE_OF_SIGNS,
+    TABLE_OF_SIGNS_VALUES
+} from "../pimath.interface"
+import {Fraction} from "../coefficients"
+import {Numeric} from '../numeric'
+import {EquationSolver} from './equationSolver'
+import {Monom} from './monom'
+import {replace_in_array} from "../helpers"
+import {operation_pow} from "./operations"
+import {Solution} from "../analyze/solution"
+
+
+export type PolynomParsingType = InputValue<Polynom> | Monom
+
+export interface IEuclidean {
+    quotient: Polynom,
+    reminder: Polynom
+}
+
+/**
+ * Polynom class can handle polynoms, reorder, resolve, ...
+ * ```
+ * let P = new Polynom('3x-4')
+ * ```
+ */
+export class Polynom implements IPiMathObject<Polynom>,
+    IExpression<Polynom>,
+    IAnalyse<Polynom>,
+    IAlgebra<Polynom> {
+
+    #defaultVariable = 'x'
+    #factors: Polynom[]
+    #monoms: Monom[]
+    #roots: Solution[]
+    #rootsCache = false
+
+    constructor(value: InputValue<Fraction>)
+    constructor(value: string)
+    constructor(value: Monom)
+    constructor(value: Polynom)
+    constructor(...values: InputValue<Fraction>[])
+    constructor(...values: InputAlgebra<Polynom>[])
+    constructor(polynomString?: InputAlgebra<Polynom>, ...values: InputAlgebra<Fraction>[]) {
+        this.#monoms = []
+        this.#factors = []
+        this.#roots = []
+
+        if (polynomString !== undefined) {
+            this.parse(polynomString, ...values)
+        }
+        return this
+    }
+
+
+    /**
+     * Parse a string to a polynom.
+     * @param inputStr
+     * @param values
+     */
+    parse(inputStr: PolynomParsingType, ...values: InputAlgebra<Monom>[]): this {
+        // Reset the main variables.
+        this.#monoms = []
+        this.#factors = []
+        this.#invalidateCache()
+
+        if (typeof inputStr === 'string') {
+            return this.#parseString(inputStr, ...values as InputValue<Fraction>[])
+        } else if (
+            (typeof inputStr === 'number' || inputStr instanceof Fraction || inputStr instanceof Monom)
+            && (values.length === 0)
+        ) {
+            this.#monoms.push(new Monom(inputStr as Monom))
+        } else if (inputStr instanceof Monom && values.length > 0) {
+            this.#monoms.push(new Monom(inputStr))
+            values.forEach(m => {
+                this.#monoms.push(new Monom(m as Monom))
+            })
+        } else if (inputStr instanceof Polynom) {
+            for (const m of inputStr.monoms) {
+                this.#monoms.push(m.clone())
+            }
+        }
+
+
+        return this
+    }
+
+    /**
+     * Clone the polynom
+     */
+    copy(): this {
+        throw new NotImplementedError("copy() is not yet implemented for Polynom")
+    }
+
+    clone(): Polynom {
+        const P = new Polynom()
+        const M: Monom[] = []
+        P.#defaultVariable = this.#defaultVariable
+
+        for (const m of this.#monoms) {
+            M.push(m.clone())
+        }
+
+        P.monoms = M
+
+        return P
+    }
+
+    get tex(): string {
+        return this.#genDisplay('tex')
+    }
+
+    get display(): string {
+        return this.#genDisplay()
+    }
+
+    static xMultiply(...polynoms: InputValue<Polynom>[]): Polynom {
+        const result = new Polynom().one()
+
+        polynoms.forEach(P => {
+            result.multiply(P)
+        })
+
+        return result
+    }
+
+    add(...values: InputAlgebra<Polynom>[]): this {
+
+        for (const value of values) {
+            if (value instanceof Polynom) {
+                this.#monoms = this.#monoms.concat(value.monoms.map(m => m.clone()))
+            } else if (value instanceof Monom) {
+                this.#monoms.push(value.clone())
+            } else if (typeof value === "number" && Number.isSafeInteger(value)) {
+                this.#monoms.push(new Monom(value.toString()))
+            } else {
+                this.#monoms.push(new Monom(value))
+            }
+        }
+
+
+        return this.reduce()
+    }
+
+    commonMonom(): Monom {
+        const M = new Monom().one()
+        const numerator: number = this.gcdNumerator()
+        const denominator: number = this.gcdDenominator()
+
+        M.coefficient = new Fraction(numerator, denominator)
+        for (const L of this.variables) {
+            // Initialize the setLetter with the max degree
+            M.setLetter(L, this.degree(L))
+            for (const m of this.#monoms) {
+                M.setLetter(L, Fraction.min(m.degree(L), M.degree(L)))
+                if (M.degree(L).isZero()) {
+                    break
+                }
+
+            }
+        }
+        return M
+    }
+
+    degree(letter?: string): Fraction {
+        let d: Fraction = new Fraction().zero()
+        for (const m of this.#monoms) {
+            d = Fraction.max(m.degree(letter).value, d)
+        }
+
+        return d
+    }
+
+    derivative(letter?: string): Polynom {
+        const dP = new Polynom()
+
+        for (const m of this.#monoms) {
+            dP.add(m.derivative(letter))
+        }
+
+        return dP.reduce()
+    }
+
+    divide(value: InputAlgebra<Polynom>): this {
+
+        if (value instanceof Fraction) {
+            return this.#divideByFraction(value)
+        } else if (typeof value === 'number' && Number.isSafeInteger(value)) {
+            return this.#divideByInteger(value)
+        } else if (value instanceof 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 {
+                const {quotient, reminder} = this.euclidean(value)
+                if (reminder.isZero()) {
+                    this.#monoms = quotient.monoms
+                    this.#invalidateCache()
+                    return this
+                }
+            }
+        } else if (typeof value === 'string') {
+            return this.divide(new Polynom(value))
+        }
+
+        throw new MathError(`Cannot divide by ${value as unknown as string}`)
+    }
+
+    empty(): this {
+        this.#monoms = []
+        this.#invalidateCache()
+        return this
+    }
+
+    /**
+     * Divide the current polynom by another polynom.
+     * @param P
+     * returns {quotient: Polynom, reminder: Polynom}
+     */
+    euclidean(P: Polynom): IEuclidean {
+        const letter: string | undefined = P.variables[0]
+        const quotient: Polynom = new Polynom().zero()
+        const reminder: Polynom = this.clone().reorder(letter)
+
+        // There is no variable - means it's a number
+        if (P.variables.length === 0) {
+            const q = this.clone().divide(P)
+
+            return {
+                quotient: q.reduce(),
+                reminder: new Polynom().zero()
+            }
+        }
+
+        if (!this.degree(letter).isNatural() || !P.degree(letter).isNatural()) {
+            throw new MathError('Euclidean division requires integer degrees')
+        }
+
+        // Get at least a letter
+        const maxMP: Monom = P.monomByDegree(undefined, letter)
+        const degreeP: Fraction = P.degree(letter)
+
+        let newM: Monom
+
+        // Make the Euclidean division of the two polynoms.
+        let MaxIteration = this.degree(letter).value - degreeP.value + 1
+
+        while (reminder.degree(letter).isGeq(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()) {
+                continue
+            }
+
+            // Get the new quotient and reminder.
+            quotient.add(newM)
+            reminder.subtract(P.clone().multiply(newM)).reduce()
+
+            // Check if the reminder is zero.
+            if (newM.degree(letter).isZero()) {
+                break
+            }
+        }
+
+        quotient.reduce()
+        reminder.reduce()
+        return {quotient, reminder}
+    }
+
+    evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric: true): number
+    evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric?: false): Fraction
+    evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric?: boolean): Fraction | number
+    evaluate(values: literalType<Fraction | number> | InputValue<Fraction>, asNumeric?: boolean): Fraction | number {
+        // Return the numeric value without using Fraction
+        if (asNumeric) {
+            return this.#evaluateAsNumeric(values)
+        }
+
+        // Build the evaluated fraction
+        const r = new Fraction().zero()
+        this.#monoms.forEach(monom => {
+            r.add(monom.evaluate(values, asNumeric))
+        })
+
+        return r
+    }
+
+    // -------------------------------------
+    /**
+     * Factorize a polynom and store the best results in factors.
+     * @param _letter
+     * TODO: Handle other letter than 'x'.
+     */
+    factorize(_letter?: string): Polynom[] {
+        this.#factors = []
+
+        // There is only one monom - it's already considered as factor.
+        if (this.monoms.length === 1) return [this.clone()]
+
+        let P = this.clone().reorder()
+
+        // Extract the common monom
+        // 2x^3+6x^2 => 2x^2
+        const M = P.commonMonom()
+
+        // If the polynom starts with a negative monom, factorize it.
+        if (P.monomByDegree().coefficient.isStrictlyNegative()) M.opposite()
+
+        if (!M.isOne()) {
+            this.#factors.push(new Polynom(M))
+            P = P.euclidean(this.#factors[0]).quotient
+        }
+
+        const solutions = new EquationSolver(P).solve()
+
+        if (solutions.length === 0) {
+            if (this.#factors.length === 0) {
+                // No common monom was extracted: the whole polynomial is irreducible
+                this.#factors = [this.clone()]
+            } else {
+                // Common monom was extracted: P is the irreducible remaining part
+                this.#factors.push(P)
+            }
+            return this.#factors
+        }
+
+        solutions.forEach(sol => {
+            if (sol.exact && sol.root.isZero()) {
+                for (let i = 0; i < sol.count; i++) {
+                    if (sol.fraction.hasFractionalPart()) {
+                        this.#factors.push(new Polynom().fromCoefficients(sol.fraction.denominator, -sol.fraction.numerator))
+                    } else {
+                        this.#factors.push(new Polynom().fromCoefficients(1, sol.fraction.clone().opposite()))
+                    }
+                }
+            }
+        })
+
+        // Check if we have all factors.
+        const fDegrees = this.#factors
+            .map(f => f.degree().value)
+            .reduce((a, b) => a + b, 0)
+
+        if (fDegrees < this.degree().value) {
+            // missing polynom.
+            const fPolynom = Polynom.xMultiply(...this.#factors)
+            this.#factors.push(this.clone().divide(fPolynom))
+        }
+
+        return this.#factors
+    }
+
+    get factors(): Polynom[] {
+        if (this.#factors.length === 0 && !this.isZero()) {
+            return this.factorize()
+        }
+
+        return this.#factors
+    }
+
+    fromCoefficients(...values: InputValue<Fraction>[]): this {
+
+        this.#monoms = []
+        const letter = this.#defaultVariable ?? 'x'
+        values.reverse().forEach((coeff, index) => {
+            const monom = new Monom()
+            monom.coefficient = new Fraction(coeff)
+            monom.setLetter(letter, index)
+
+            this.#monoms.push(monom)
+        })
+
+        this.#invalidateCache()
+        return this.reorder()
+    }
+
+    gcdDenominator(): number {
+        return Numeric.gcd(...this.getDenominators())
+    }
+
+    gcdNumerator(): number {
+        return Numeric.gcd(...this.getNumerators())
+    }
+
+    getCoefficients(): Fraction[] {
+        if (!this.degree().isNatural()) {
+            throw new MathError('getCoefficients() requires a polynomial with integer degrees')
+        }
+
+        // Assume there is only one letter.
+        const orderedPolynom = this.clone().reorder()
+
+        const length = this.degree().value + 1
+        const coeffs = Array.from({length}, () => new Fraction(0))
+
+        orderedPolynom.monoms.forEach(monom => {
+            const index = length - monom.degree().value - 1
+            coeffs[index] = monom.coefficient.clone()
+        })
+
+        return coeffs
+    }
+
+    // Next functions are used for for commonMonom, which is used in the factorize method.
+    getDenominators(): number[] {
+        const denominators: number[] = []
+        for (const m of this.#monoms) {
+            denominators.push(m.coefficient.denominator)
+        }
+
+        return denominators
+    }
+
+    getNumerators(): number[] {
+        const numerators: number[] = []
+        for (const m of this.#monoms) {
+            numerators.push(m.coefficient.numerator)
+        }
+
+        return numerators
+    }
+
+    getZeroes(): Solution[] {
+        if (this.degree().isZero()) {
+            return []
+        }
+
+        this.roots = new EquationSolver(this.clone()).solve()
+        return this.roots
+    }
+
+    hasVariable(letter: string): boolean {
+        return this.variables.includes(letter)
+    }
+
+    integrate(a: InputValue<Fraction>, b: InputValue<Fraction>, letter = 'x'): Fraction {
+        const primitive = this.primitive(letter)
+
+        const valuesA: literalType<Fraction> = {}
+        const valuesB: literalType<Fraction> = {}
+
+        valuesA[letter] = new Fraction(a)
+        valuesB[letter] = new Fraction(b)
+
+        return (primitive.evaluate(valuesB)).subtract(primitive.evaluate(valuesA))
+    }
+
+    inverse(): Polynom | undefined {
+        return undefined
+    }
+
+    isDeveloped(polynomString: string): boolean {
+        // Start by removing the parenthesis after a "power"
+        const pString = polynomString.replaceAll(/\^\(([-0-9/]+)\)/g, '$1')
+
+        // There is at least one parenthesis - it is not developed.
+        if (pString.includes('(') || pString.includes(')')) {
+            return false
+        }
+
+
+        // Build the polynom. A malformed string throws (ParseError) instead of
+        // being silently treated as "not developed".
+        const P = new Polynom(polynomString)
+
+        // 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
+    }
+
+    isDividableBy(div: Polynom): boolean {
+        // Quick evaluation.
+        if (div.degree().isOne()) {
+            const zero = div.getZeroes()[0]
+
+            if (zero.exact) {
+                return (this.evaluate(zero.fraction)).isZero()
+            } else {
+                return false
+            }
+
+        } else {
+            const {reminder} = this.euclidean(div)
+            return reminder.isZero()
+        }
+    }
+
+    isEqual(P: Polynom): boolean {
+        return this.#compare(P, '=')
+    }
+
+    get isMultiVariable(): boolean {
+        // Determine if a monom has more than one variable.
+        return this.#monoms.some(m => m.variables.length > 1)
+    }
+
+    isOne(): boolean {
+        return this.#monoms.length === 1 && this.#monoms[0].coefficient.isOne() && this.degree().isZero()
+    }
+
+    isOppositeAt(P: Polynom): boolean {
+        return this.#compare(P.clone().opposite(), '=')
+    }
+
+    isSameAs(P: Polynom): boolean {
+        return this.#compare(P, 'same')
+    }
+
+    isZero(): boolean {
+        return (this.#monoms.length === 1 && this.#monoms[0].coefficient.isZero()) || this.#monoms.length === 0
+    }
+
+    lcmDenominator(): number {
+        return Numeric.lcm(...this.getDenominators())
+    }
+
+    lcmNumerator(): number {
+        return Numeric.lcm(...this.getNumerators())
+    }
+
+    get length() {
+        return this.#monoms.length
+    }
+
+    limitTo(value: InputValue<Fraction>, letter?: string): Fraction {
+        const f = new Fraction(value)
+
+        // Finite value: evaluate directly
+        if (f.isFinite()) {
+            const l = letter ?? this.variables[0] ?? 'x'
+            return this.evaluate({[l]: f})
+        }
+
+        const M = this.monomByDegree(undefined, letter)
+        const sign = M.coefficient.sign()
+        const degree = M.degree(letter)
+
+        // Constant polynomial
+        if (degree.isZero()) {
+            return M.coefficient.clone()
+        }
+
+        if (!degree.isStrictlyPositive()) {
+            return new Fraction().zero()
+        }
+
+        // Limit at +∞: determined by the leading coefficient sign
+        if (f.isPositive()) {
+            return sign === 1
+                ? new Fraction().infinite()
+                : new Fraction().infinite().opposite()
+        }
+
+        // Limit at -∞: accounts for the parity of the degree
+        const degreeIsEven = degree.value % 2 === 0
+        const limitSign = degreeIsEven ? sign : -sign
+        return limitSign === 1
+            ? new Fraction().infinite()
+            : new Fraction().infinite().opposite()
+    }
+
+    monomByDegree(degree?: Fraction | number, letter?: string): Monom {
+        // return the highest degree monom.
+        if (degree === undefined) {
+            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().zero()
+    }
+
+    // Used in LinearSystem.tex
+    monomByLetter(letter: string): Monom {
+        const M = this.clone().reduce()
+        for (const m of M.#monoms) {
+            if (m.hasVariable(letter)) {
+                return m.clone()
+            }
+        }
+
+        return new Monom().zero()
+    }
+
+    // ------------------------------------------
+    get monoms() {
+        return this.#monoms
+    }
+
+    set monoms(M: Monom[]) {
+        this.#monoms = M
+        this.#invalidateCache()
+    }
+
+    monomsByDegree(degree?: number | Fraction, letter?: string): Monom[] {
+        // return the highest degree monom.
+        if (degree === undefined) {
+            return this.monomsByDegree(this.degree(letter), letter)
+        }
+
+        // Reduce the polynom.
+        const Ms: Monom[] = []
+
+        const M = this.clone().reduce()
+        for (const m of M.#monoms) {
+            if (m.degree(letter).isEqual(degree)) {
+                Ms.push(m.clone())
+            }
+        }
+
+        return Ms
+    }
+
+    multiply(value: InputAlgebra<Polynom>): this {
+
+        if (value instanceof Polynom) {
+            return this.#multiplyByPolynom(value)
+        }
+
+        if (value instanceof Fraction) {
+            return this.#multiplyByFraction(value)
+        }
+
+        if (value instanceof Monom) {
+            return this.#multiplyByMonom(value)
+        }
+
+        if (Number.isSafeInteger(value) && typeof value === 'number') {
+            return this.#multiplyByInteger(value)
+        }
+
+        if (typeof value === 'string') {
+            try {
+                const k = new Fraction(value)
+                return this.#multiplyByFraction(k)
+            } catch (e) {
+                throw new MathError('Cannot multiply by this value.', {cause: e})
+            }
+        }
+
+        // Something went wrong...
+        throw new MathError(`Cannot multiply by this value: ${value as unknown as string}`)
+    }
+
+    get numberOfVars(): number {
+        return this.variables.length
+    }
+
+    one(): this {
+        this.#monoms = []
+        this.#monoms.push(new Monom().one())
+        this.#invalidateCache()
+        return this
+    }
+
+    // ------------------------------------------
+    opposite(): this {
+        this.#monoms = this.#monoms.map(m => m.opposite())
+        this.#invalidateCache()
+        return this
+    }
+
+    get plotFunction(): string {
+        return this.#genDisplay('tex', false, false, true)
+    }
+
+    pow(nb: number): Polynom {
+        return operation_pow(this as Polynom, nb).reduce()
+    }
+
+    primitive(letter?: string): Polynom {
+        const dP = new Polynom()
+
+        for (const m of this.#monoms) {
+            dP.add(m.primitive(letter))
+        }
+
+        return dP
+    }
+
+    reduce(): this {
+        // Reduce the polynom
+
+        // 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().zero()
+                    }
+
+                    j--
+                }
+            }
+
+            i++
+        }
+
+        // Remove all null monoms
+        this.#monoms = this.#monoms.filter((m) => {
+            return !m.coefficient.isZero()
+        })
+
+        // Reduce all monoms coefficient.
+        for (const m of this.#monoms) {
+            m.coefficient.reduce()
+        }
+
+        if (this.length === 0) {
+            return this.zero()
+        }
+
+        this.#invalidateCache()
+        return this.reorder()
+    }
+
+    reorder(letter = 'x', revert = false): this {
+        const otherLetters = this.variables.filter(x => x !== letter)
+        this.#monoms.sort(function (a, b) {
+            const da = a.degree(letter).value
+            const 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 reverted in that case !
+            if (otherLetters.length > 0) {
+                for (const L of otherLetters) {
+                    const da = a.degree(L).value
+                    const db = b.degree(L).value
+
+                    // Values are different
+                    if (da !== db) {
+                        return revert ? da - db : db - da
+                    }
+                }
+            }
+
+
+            return 0
+        })
+
+        return this
+    }
+
+    /**
+     * Replace a variable (letter) by a polynom.
+     * @param letter
+     * @param P
+     */
+    replaceBy(letter: string, P: Polynom): this {
+        let pow: Fraction
+        const resultPolynom: Polynom = new Polynom().zero()
+
+        for (const m of this.monoms) {
+            if (!m.hasVariable(letter) || m.literal[letter].isZero()) {
+                resultPolynom.add(m.clone())
+            } else {
+                // We have found a variable to replace.
+
+                // Get the power.
+                pow = m.literal[letter].clone()
+
+                // Remove the variable from the monom
+                m.removeVariable(letter)
+
+                // Add the new monom to the result polynom
+                if (pow.isStrictlyNegative()) {
+                    throw new MathError(`Cannot replace variable "${letter}" with negative power in a Polynom`)
+                }
+                resultPolynom.add(P.clone().pow(pow.numerator).multiply(m))
+            }
+        }
+
+
+        // Reduce the monoms
+        this.#monoms = resultPolynom.reduce().monoms
+        this.#invalidateCache()
+        return this
+    }
+
+    // ------------------------------------------
+
+    root(): Polynom {
+        throw new MathError('Cannot take the root from a polynom')
+    }
+
+    get roots(): Solution[] {
+        return this.#rootsCache ? this.#roots : this.getZeroes()
+    }
+
+    set roots(value: Solution[]) {
+        this.#rootsCache = true
+        this.#roots = value
+    }
+
+    setVariable(value: string): this {
+        this.#defaultVariable = value
+
+        return this
+    }
+
+    sqrt(): Polynom {
+        throw new MathError('Cannot take the square root from a polynom')
+    }
+
+    subtract(...values: InputAlgebra<Polynom>[]): this {
+        for (const value of values) {
+            if (value instanceof Polynom) {
+                this.add(value.clone().opposite())
+            } else if (value instanceof Monom) {
+                this.#monoms.push(value.clone().opposite())
+            } else {
+                this.#monoms.push(new Monom(value).opposite())
+            }
+        }
+
+
+        return this.reduce()
+    }
+
+    tableOfSigns(): TABLE_OF_SIGNS {
+        // returns ['+-', 'd|t|z', '+-']...
+
+        // global roots from eventually Polyfactor. Allows to add "extra column".
+        const roots: Solution[] = this.roots
+
+        // Build the table os sign length and default values
+        // The signs looks like: ['+', 't', '+', 't', '+', 't', '+']
+        let signs: TABLE_OF_SIGNS_VALUES[] = new Array(2 * roots.length + 1)
+            .fill('')
+            .map((_x, index) => {
+                return index % 2 === 0 ? '' : 'z'
+            })
+
+
+        if (signs.length === 1) {
+            // The polynom is a constant or has not roots
+            const [a] = this.getCoefficients().map(x => x.value)
+            signs = replace_in_array(signs, '', a > 0 ? '+' : '-')
+        } else if (this.degree().isOne()) {
+            // First degree: ax+b
+            const [a] = this.getCoefficients().map(x => x.value)
+
+            // Get the index of the zero.
+            signs[0] = a > 0 ? '-' : '+'
+            signs[1] = 'z'
+            signs[2] = a > 0 ? '+' : '-'
+        } else {
+            const testingRoots = [
+                roots[0].value - 1,
+                ...roots.map((_root, index) => {
+                    return index === roots.length - 1 ?
+                        roots[index].value + 1 :
+                        (roots[index].value + roots[index + 1].value) / 2
+                })
+            ]
+
+            testingRoots.forEach((test, index) => {
+                const sign = this.evaluate({[this.variables[0] ?? 'x']: test}, true)
+                signs[index * 2] = sign > 0 ? '+' : '-'
+            })
+        }
+
+        return {roots, signs}
+    }
+
+    get value(): number | undefined {
+        if (this.degree().isZero()) {
+            return this.monoms[0]?.coefficient.value ?? 0
+        }
+
+        return undefined
+    }
+
+    get variables(): string[] {
+        return [...new Set(this.#monoms.flatMap(m => m.variables))].sort()
+    }
+
+    /**
+     * Set the polynom to zero.
+     * @returns {this}
+     */
+    zero(): this {
+        this.#monoms = []
+        this.#monoms.push(new Monom().zero())
+        this.#invalidateCache()
+        return this
+    }
+
+    get zeroes(): Solution[] {
+        return this.getZeroes()
+    }
+
+    #compare(P: Polynom, sign?: string): boolean {
+        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().isEqual(cP2.degree())) {
+                    return false
+                }
+
+                // Check if the coefficients are the isSame.
+                return cP1.monoms
+                    .every((m1, index) => m1.isEqual(cP2.monoms[index]))
+
+            case 'same':
+                // They must have the same length and the same degree
+                if (cP1.length !== cP2.length || !cP1.degree().isEqual(cP2.degree())) {
+                    return false
+                }
+
+                return cP1.monoms
+                    .every((m1, index) => m1.isSameAs(cP2.monoms[index]))
+
+            default:
+                return false
+        }
+    }
+
+    #divideByFraction(F: Fraction): this {
+        for (const m of this.#monoms) {
+            m.coefficient.divide(F)
+        }
+
+        this.#invalidateCache()
+        return this
+    }
+
+    #divideByInteger(nb: number): this {
+        const nbF = new Fraction(nb)
+        for (const m of this.#monoms) {
+            m.coefficient.divide(nbF)
+        }
+
+        this.#invalidateCache()
+        return this
+    }
+
+    #evaluateAsNumeric(values: literalType<number | Fraction> | InputValue<Fraction>): number {
+        let r = 0
+        this.#monoms.forEach(monom => {
+            r += monom.evaluate(values, true) as number
+        })
+
+        return r
+    }
+
+    #genDisplay(output?: string, forceSign?: boolean, wrapParentheses?: boolean, withAllMultiplicationSign?: boolean): string {
+        let P = ''
+
+        for (const k of this.#monoms) {
+            if (k.coefficient.value === 0) {
+                continue
+            }
+
+            // The monom to be displayed
+            let m
+            if (withAllMultiplicationSign) {
+                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
+    }
+
+    #invalidateCache(): void {
+        this.#rootsCache = false
+        this.#factors = []
+    }
+
+    #multiplyByFraction(F: Fraction): this {
+        for (const m of this.#monoms) {
+            m.coefficient.multiply(F)
+        }
+
+        return this.reduce()
+    }
+
+    #multiplyByInteger(nb: number): this {
+        return this.#multiplyByFraction(new Fraction(nb))
+    }
+
+    #multiplyByMonom(M: Monom): this {
+        for (const m of this.#monoms) {
+            m.multiply(M)
+        }
+
+        return this.reduce()
+    }
+
+    #multiplyByPolynom(P: Polynom): this {
+        const M: Monom[] = []
+        for (const m1 of this.#monoms) {
+            for (const m2 of P.monoms) {
+                M.push(Monom.xMultiply(m1, m2))
+            }
+        }
+
+        this.#monoms = M
+        return this.reduce()
+    }
+
+    #parseString(inputStr: string, ...values: InputValue<Fraction>[]): this {
+        if (values.length === 0) {
+            // Parse the polynom using the shutting yard algorithm
+            if (inputStr !== '' && !isNaN(Number(inputStr))) {
+                this.empty()
+                // It's a simple number.
+                const m = new Monom(Number(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()
+
+            const fractions = values.map(x => new Fraction(x))
+
+            // Multiple setLetter version
+            if (inputStr.length > 1) {
+                const letters = inputStr.split('')
+
+                if (fractions.length > letters.length + 1) {
+                    throw new InvalidArgumentError(`Too many values: ${letters.length} letters but ${fractions.length} values provided`)
+                }
+
+                let i = 0
+
+                for (const F of fractions) {
+                    const m = new Monom()
+                    m.coefficient = F.clone()
+                    m.literalStr = letters[i] ?? ''
+                    this.add(m)
+                    i++
+                }
+            }
+            // Single setLetter version
+            else {
+                let n = fractions.length - 1
+                for (const F of fractions) {
+                    const m = new Monom()
+                    m.coefficient = F.clone()
+                    m.literalStr = `${inputStr}^${n}`
+                    this.add(m)
+                    n--
+                }
+            }
+            return this
+        } else {
+            return this.zero()
+        }
+
+    }
+
+    #shutingYardAddToken(stack: Polynom[], element: Token): void {
+        switch (element.tokenType) {
+            case ShutingyardType.COEFFICIENT:
+                stack.push(new Polynom(element.token))
+                break
+
+            case ShutingyardType.VARIABLE:
+                stack.push(new Polynom().add(new Monom(element.token)))
+                break
+
+            case ShutingyardType.CONSTANT:
+                throw new ParseError('Unsupported CONSTANT token in Polynom parser')
+
+            case ShutingyardType.OPERATION:
+                if (stack.length >= 2) {
+                    const b = stack.pop()
+                    const a = stack.pop()
+
+                    // Check if the polynoms are not undefined.
+                    if (a === undefined || b === undefined) {
+                        throw new ParseError('Unexpected undefined operand in Polynom parser stack')
+                    }
+
+                    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()) {
+                            throw new MathError('Cannot divide a Polynom by another Polynom of degree > 0')
+                        } else {
+                            // a.divide(b.monoms[0].coefficient)
+                            stack.push(a.divide(b.monoms[0].coefficient))
+                        }
+                    } else if (element.token === '^') {
+                        if (b.degree().isStrictlyPositive()) {
+                            throw new MathError('Cannot elevate a polynom with another polynom !')
+                        } else if (b.monoms[0].coefficient.isNatural())
+                            // Natural (positive) 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 (const letter in a.monoms[0].literal) {
+                                    a.monoms[0].literal[letter].multiply(b.monoms[0].coefficient)
+                                }
+
+                                stack.push(a)
+                            } else {
+                                throw new MathError('Cannot raise a multi-monom Polynom to a fractional power')
+                            }
+                        }
+                    }
+
+                } else if (element.token === '-') {
+                    const a = stack.pop()
+                    if (a) {
+                        stack.push(a.opposite())
+                    }
+                } else {
+                    throw new ParseError("Error parsing the polynom")
+                }
+
+
+                break
+
+            case ShutingyardType.MONOM:
+                // Should never appear.
+                throw new ParseError('Unexpected MONOM token in polynom parser')
+
+            case ShutingyardType.FUNCTION:
+                // Should never appear.
+                throw new ParseError(`Unsupported function token "${element.token}" in polynom parser`)
+        }
+
+
+    }
+
+    /**
+     * Main parse using a shutting yard class
+     * @param inputStr
+     */
+    #shutingYardToReducedPolynom(inputStr: string): this {
+        // Get the RPN array of the current expression
+        let SY: ShutingYard
+        try {
+            SY = new ShutingYard().parse(inputStr)
+        } catch (e) {
+            throw new ParseError(`Cannot parse "${inputStr}" as a Polynom`, {cause: e})
+        }
+        const rpn: { token: string, tokenType: ShutingyardType }[] = SY.rpn
+
+        // New version for reducing shuting yard.
+        this.zero()
+
+        const stack: Polynom[] = []
+
+        // Loop through the each element of the RPN
+        for (const element of rpn) {
+            this.#shutingYardAddToken(stack, element)
+        }
+
+
+        if (stack.length === 1) {
+            this.add(stack[0])
+        }
+
+
+        return this.reorder()
+    }
+
+
+}