pimath 0.2.13 → 0.2.15

package/src/algebra/monom.ts

@@ -1,928 +1,932 @@
-/***
- * Monom class
- */
-import type {
-    IAlgebra,
-    IAnalyse,
-    IExpression,
-    InputAlgebra,
-    InputValue,
-    IPiMathObject,
-    literalType
-} from "../pimath.interface"
-import {Fraction} from "../coefficients"
-import {Numeric} from "../numeric"
-
-import {ShutingYard, ShutingyardType, type Token} from "piexpression"
-import {MathError, NotImplementedError, ParseError} from "../errors"
-
-export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse<Monom>, IAlgebra<Monom> {
-    #coefficient: Fraction
-    #literal: literalType<Fraction>
-
-    constructor(value?: InputValue<Fraction>)
-    constructor(value?: Monom)
-    constructor(value?: InputAlgebra<Fraction>) {
-        this.#coefficient = new Fraction().zero()
-        this.#literal = {}
-
-        if (value !== undefined) {
-            // A string is given - try to parse the value.
-            this.parse(value)
-        }
-
-        return this
-    }
-
-    // -----------------------------------------
-    /**
-     * Parse a string to a monom. The string may include fraction.
-     * @param inputStr
-     */
-    public parse(inputStr: InputAlgebra<Monom>): this {
-        // Initialize the monom
-        this.#coefficient = new Fraction()
-        this.#literal = {}
-
-        if (inputStr instanceof Monom) {
-            this.#coefficient = inputStr.#coefficient.clone()
-
-            // Copy the literal parts
-            this.#cloneLiteral(inputStr)
-            return this
-        }
-
-        if (inputStr instanceof Fraction) {
-            this.#coefficient = inputStr.clone()
-            return this
-        }
-
-        if (typeof inputStr === 'number') {
-            this.#coefficient = new Fraction(inputStr)
-            return this
-        }
-
-
-        if (!isNaN(Number(inputStr))) {
-            this.#coefficient = new Fraction(Number(inputStr))
-        } else {
-            this.#shutingYardToReducedMonom(inputStr)
-        }
-        return this
-    }
-
-    /**
-     * Clone the current Monom.
-     */
-    public clone = (): Monom => {
-        const F: Monom = new Monom()
-
-        F.coefficient = this.#coefficient.clone()
-
-        // Copy the literal parts.
-        for (const k in this.#literal) {
-            F.setLetter(k, this.#literal[k].clone())
-        }
-        return F
-    }
-
-    /**
-     * Get the tex output of the monom
-     */
-    public get tex(): string {
-        return this.#format('tex')
-    }
-
-    // Display getter
-    /**
-     * This display getter is to be used in the polynom display getter
-     */
-    public get display(): string {
-        return this.#format('display')
-    }
-
-    public static gcd = (...monoms: Monom[]): Monom => {
-        // All the monoms must be with natural powers...
-        for (const m of monoms) {
-            if (m.containsRationalPower()) {
-                return new Monom().zero()
-            }
-        }
-
-        const M = new Monom(),
-            n: number = Numeric.gcd(...monoms.map(value => value.coefficient.numerator)),
-            d: number = Numeric.lcm(...monoms.map(value => value.coefficient.denominator))
-
-        // Get the coefficient.
-        M.coefficient = new Fraction(n, d).reduce()
-
-        // Set the literal parts - go through each monoms literal parts and get only the lowest degree of each letters.
-        for (const m of monoms) {
-            // Remove the inexistant letters from the resulting monom
-            for (const letter in M.literal) {
-                if (!(letter in m.literal)) {
-                    M.removeVariable(letter)
-                }
-            }
-            for (const letter in m.literal) {
-                if (!M.hasVariable(letter) && m.literal[letter].isStrictlyPositive()) {
-                    M.literal[letter] = m.literal[letter].clone()
-                } else {
-                    M.literal[letter] = new Fraction(Math.min(m.literal[letter].value, M.literal[letter].value))
-                }
-            }
-        }
-
-        return M
-    }
-
-    /**
-     * Multiply two monoms and return a NEW monom.
-     * @param monoms
-     */
-    public static xMultiply = (...monoms: Monom[]): Monom => {
-        const M = new Monom().one()
-
-        for (const m of monoms) {
-            M.multiply(m)
-        }
-
-        return M
-    }
-
-    /**
-     * Add all similar monoms. If they aren't similar, they are simply skipped.
-     * @param M (Monom[]) The monoms to add.
-     */
-    public add = (...M: InputAlgebra<Fraction>[]): this => {
-        for (const m of M) {
-            // If the value given is not a monom, create it.
-            const mAsMonom = (!(m instanceof Monom)) ? new Monom(m) : m
-
-            if (this.isSameAs(mAsMonom)) {
-                if (this.isZero()) {
-                    this.#cloneLiteral(mAsMonom)
-                }
-
-                this.#coefficient.add(mAsMonom.coefficient)
-            } else {
-                throw new MathError('Add monom: ' + this.display + ' is not similar with ' +  mAsMonom.display)
-            }
-        }
-        return this
-    }
-
-    /**
-     * Get the coefficient \\(k\\) of the Monom \\(k\\cdot x^{n}\\)
-     * @returns {Fraction}
-     */
-    public get coefficient(): Fraction {
-        return this.#coefficient
-    }
-
-    /**
-     * Set the coefficient \\(k\\) value of the monom
-     * @param {Fraction | number | string} F
-     */
-    public set coefficient(F: InputValue<Fraction>) {
-        this.#coefficient = new Fraction(F)
-    }
-
-    public containsRationalPower = (): boolean => {
-        return Object.values(this.#literal).some((value) => value.isRational())
-    }
-
-    /**
-     * Get the degree of a monom. If no setLetter is given, the result will be the global degree.
-     * @param letter (string) Letter to get to degree (power)
-     */
-    public degree = (letter?: string): Fraction => {
-        if (this.variables.length === 0) {
-            return new Fraction().zero()
-        }
-        if (letter === undefined) {
-            // Not setLetter given -> we get the global monom degree (sum of all the letters).
-            return Object.values(this.#literal).reduce((t, n) => t.clone().add(n))
-        } else {
-            // A setLetter is given -> get the corresponding power.
-            return !this.hasVariable(letter) ? new Fraction().zero() : this.#literal[letter].clone()
-        }
-    }
-
-    /**
-     * Derivative the monom
-     * @param letter
-     */
-    public derivative = (letter = 'x'): Monom => {
-        // No setLetter given - assume it's the setLetter 'x'
-        if (this.hasVariable(letter)) {
-            const d = this.#literal[letter].clone(),
-                dM = this.clone()
-
-            // Subtract one to the degree.
-            dM.#literal[letter].subtract(1)
-
-            // Multiply the coefficient by the previous degree
-            dM.#coefficient.multiply(new Fraction(d.clone()))
-            return dM
-        } else {
-            return new Monom().zero()
-        }
-    }
-
-    /**
-     * Divide the current monoms by multiple monoms
-     * @param M (Monom[])
-     */
-    public divide = (...M: InputAlgebra<Fraction>[]): this => {
-        // Depending on the given value, choose the current item
-        for (const m of M) {
-            // If the value given is not a monom, create it.
-            const mAsMonom = (!(m instanceof Monom)) ? new Monom(m) : m
-
-            // Divide the coefficient
-            this.#coefficient.divide(mAsMonom.coefficient)
-
-            // Subtract the power values
-            for (const letter in mAsMonom.literal) {
-
-                this.#literal[letter] = this.hasVariable(letter) ?
-                    this.#literal[letter].subtract(mAsMonom.literal[letter]) :
-                    mAsMonom.literal[letter].clone().opposite()
-
-
-                // If the power of a particular setLetter is zero, delete it from the literal part..
-                if (this.#literal[letter].isZero()) {
-                    this.removeVariable(letter)
-                }
-            }
-        }
-        return this
-    }
-
-    public get dividers(): Monom[] {
-        // Decompose only if the coefficient is a natural number
-        if (!this.coefficient.isRelative()) {
-            return [this.clone()]
-        }
-
-        // Decompose only if the power values are natural numbers.
-        if (this.containsRationalPower()) {
-            return [this.clone()]
-        }
-
-        // Security : do not do this if greater than 10000
-        if (this.coefficient.numerator > 1000000) {
-            return [this.clone()]
-        }
-
-        const dividers = Numeric.dividers(Math.abs(this.coefficient.numerator))
-
-        // Decompose the literals parts.
-        let literals: literalType<Fraction>[] = []
-        for (const L in this.literal) {
-            // L is the letter.
-            literals = this.#getLiteralDividers(literals, L)
-        }
-
-        const monomDividers: Monom[] = []
-        if (literals.length > 0 && dividers.length > 0) {
-            for (const N of dividers) {
-                for (const L of literals) {
-                    const M = new Monom()
-                    M.coefficient = new Fraction(N)
-                    M.literal = L
-                    monomDividers.push(M)
-                }
-            }
-        } else if (dividers.length === 0) {
-            for (const L of literals) {
-                const M = new Monom()
-                M.coefficient = new Fraction().one()
-                M.literal = L
-                monomDividers.push(M)
-            }
-        } else {
-            for (const N of dividers) {
-                const M = new Monom()
-                M.coefficient = new Fraction(N)
-                monomDividers.push(M)
-            }
-        }
-
-        return monomDividers.length === 0 ? [new Monom().one()] : monomDividers
-    }
-
-    /**
-     * Evaluate a monom. Each setLetter must be assigned to a Fraction.
-     * @param values    Dictionary of <setLetter: Fraction>
-     * @param asNumeric
-     */
-    public evaluate = (values: literalType<number | Fraction> | InputValue<Fraction>, asNumeric?: boolean): Fraction | number => {
-        // If as numeric return the numeric value
-        if (asNumeric === true) {
-            // Convert all values to numeric
-            // If the value is a Fraction, convert it to a number
-            if (values instanceof Fraction) {
-                return this.#evaluateAsNumeric(values.value)
-            }
-
-            // If the value is a number, return the numeric value
-            if (typeof values === 'number') {
-                return this.#evaluateAsNumeric(values)
-            }
-
-            // If the value is an object, return the numeric value
-            if (typeof values === 'object') {
-                // Convert {[key:string]:Fraction} to {[key:string]:number}
-                const tmpValues: literalType<number> = {}
-                for (const L in values) {
-                    tmpValues[L] = new Fraction(values[L]).value
-                }
-
-                return this.#evaluateAsNumeric(tmpValues)
-            }
-        }
-
-        // The answer must be a Fraction
-        const r = this.coefficient.clone()
-
-        if (typeof values === 'number' || values instanceof Fraction) {
-            const tmpValues: literalType<Fraction> = {}
-            tmpValues[this.variables[0]] = new Fraction(values)
-            return this.evaluate(tmpValues)
-        }
-
-        if (typeof values === 'object') {
-            if (this.variables.length === 0) {
-                return this.coefficient
-            }
-
-            for (const L in this.#literal) {
-                const value = new Fraction(values[L])
-
-                r.multiply(value.pow(this.#literal[L]))
-            }
-        }
-
-        return r
-    }
-
-    // -------------------------------------
-    /**
-     * Determine if a monom contains a setLetter in it's literal part
-     * @param letter
-     */
-    public hasVariable = (letter?: string): boolean => {
-        // The letter was not found
-        return Object.hasOwn(this.#literal, letter ?? 'x')
-    }
-
-    public integrate(a: InputValue<Fraction>, b: InputValue<Fraction>, letter?: string): Fraction {
-        const primitive = this.primitive(letter)
-
-        return (primitive.evaluate(b, false) as Fraction)
-            .subtract(primitive.evaluate(a, false) as Fraction)
-    }
-
-    public inverse = (): this => {
-        this.#coefficient.inverse()
-        for (const letter in this.#literal) {
-            this.#literal[letter].opposite()
-        }
-        return this
-    }
-
-    public isDivisible = (div: Monom): boolean => {
-        // For all variables (letters), the current monom must have a degree higher than the divider
-        if (div.degree().isStrictlyPositive()) {
-            for (const letter of div.variables) {
-                if (!this.degree(letter).isGeq(div.degree(letter))) {
-                    return false
-                }
-            }
-        }
-
-        // If the coefficient is rational, we suppose we don't need to check the division by the coefficient.
-        if (this.coefficient.isRational() || div.coefficient.isRational()) {
-            return true
-        }
-
-        return this.coefficient.clone().divide(div.coefficient).isRelative()
-    }
-
-    /**
-     * Determine if two monoms are equals
-     * @param M
-     */
-    public isEqual = (M: Monom): boolean => {
-        return this.isSameAs(M) && this.#coefficient.isEqual(M.coefficient)
-    }
-
-    public isLiteralSquare = (): boolean => {
-        for (const letter in this.literal) {
-            // A literal square must have a natural power
-            if (this.literal[letter].isRational()) {
-                return false
-            }
-
-            // The natural power must be even - if it's odd, the monom is not a square.
-            if (this.literal[letter].isOdd()) {
-                return false
-            }
-        }
-
-        return true
-    }
-
-    /**
-     * Determine if the monom is one
-     */
-    public isOne = (): boolean => {
-        return this.#coefficient.value === 1 && this.variables.length === 0
-    }
-
-    /**
-     * Determine if two monoms are similar
-     * @param M
-     */
-    public isSameAs = (M: Monom): boolean => {
-        // Get the list of all variables from both monoms.
-        const M1: string[] = this.variables
-        const M2: string[] = M.variables
-
-        // Get the list of all variables from both monoms.
-        const K: string[] = M1.concat(M2.filter((item) => !M1.includes(item)))
-
-        // If one of the monom is zero, it is the same than the other.
-        if (this.isZero() || M.isZero()) {
-            return true
-        }
-
-        // Both monoms has no literal part.
-        if (M1.length === 0 && M2.length === 0) {
-            return true
-        }
-
-        // Both monoms must have the same variables
-        if (M1.length !== M2.length) {
-            return false
-        }
-
-        // To _compare, both must be different from zero.
-        if (!this.isZero() && !M.isZero()) {
-            for (const key of K) {
-                // The variable is not available in one of the monom
-                if (!this.hasVariable(key) || !M.hasVariable(key)) {
-                    return false
-                }
-
-                // The variable does not have the same power in each monoms.
-                if (!this.#literal[key].isEqual(M.literal[key])) {
-                    return false
-                }
-            }
-        }
-
-        // All are positive check - the monoms are the sames.
-        return true
-    }
-
-    public isSquare = (): boolean => {
-        if (!this.coefficient.isSquare()) {
-            return false
-        }
-        return this.isLiteralSquare()
-    }
-
-    /**
-     * Determine if the monom is null
-     */
-    public isZero = (): boolean => {
-        return this.#coefficient.value === 0
-    }
-
-    /**
-     * Get the literal part of \\(x^{n_1}y^{n_2}\\) as dictionary \\[\\begin{array}{ll}x&=n_1\\\\y&=n_2\\end{array}\\]
-     * @returns {literalType}
-     */
-    public get literal(): literalType<Fraction> {
-        return this.#literal
-    }
-
-    /**
-     * Set the literal part of the monom. Must be a dictionary {x: Fraction, y: Fraction, ...}
-     * @param {literalType<Fraction>} L
-     */
-    public set literal(L: literalType<Fraction>) {
-        this.#literal = L
-    }
-
-    /**
-     * Set the literal part of the monom from a string
-     * @param inputStr  String like x^2y^3
-     */
-    public set literalStr(inputStr: string) {
-        // Match all x^n
-        for (const v of [...inputStr.matchAll(/([a-z])\^([+-]?[0-9]+)/g)]) {
-            // Create the default letter entry if necessary.
-            if (!(v[1] in this.#literal)) {
-                this.#literal[v[1]] = new Fraction().zero()
-            }
-
-            // Add the new value.
-            this.#literal[v[1]].add(+v[2])
-        }
-
-        // Match all x
-        for (const v of [...inputStr.matchAll(/([a-z](?!\^))/g)]) {
-            // Match all single letters
-            if (!(v[1] in this.#literal)) {
-                this.#literal[v[1]] = new Fraction().zero()
-            }
-
-            // Add one to the value.
-            this.#literal[v[1]].add(1)
-        }
-    }
-
-    /**
-     * Multiple multiple monoms to the current monom
-     * @param M (Monom[]) The monoms to multiply to.
-     */
-    public multiply = (...M: InputAlgebra<Fraction>[]): this => {
-        for (const m of M) {
-            // If the value given is not a monom, create it.
-            const mAsMonom = (!(m instanceof Monom)) ? new Monom(m) : m
-
-            // Multiply the coefficient.
-            this.#coefficient.multiply(mAsMonom.coefficient)
-
-            // Multiply the literal parts.
-            for (const letter in mAsMonom.literal) {
-                if (!this.hasVariable(letter)) {
-                    this.#literal[letter] = mAsMonom.literal[letter].clone()
-                } else {
-                    this.#literal[letter].add(mAsMonom.literal[letter])
-                }
-            }
-        }
-        return this
-    }
-
-    /**
-     * Create a one value monom
-     */
-    public one = (): this => {
-        this.#coefficient = new Fraction().one()
-        this.#literal = {}
-        return this
-    }
-
-    /**
-     * Get the opposite
-     * Returns a monom.
-     */
-    public opposite = (): this => {
-        this.#coefficient.opposite()
-        return this
-    }
-
-    public get plotFunction(): string {
-        return this.#format('plot')
-    }
-
-    /**
-     * Get the pow of a monom.
-     * @param nb (number) : Mathematical pow
-     */
-    public pow = (nb: number | Fraction): this => {
-        this.#coefficient.pow(nb)
-        for (const letter in this.#literal) {
-            this.#literal[letter].multiply(nb)
-        }
-        return this
-    }
-
-    public primitive = (letter = 'x'): Monom => {
-        // Zero monom
-        const M = this.clone()
-        let degree: Fraction
-
-        if (M.hasVariable(letter)) {
-            degree = M.degree(letter).clone().add(1)
-            M.coefficient = M.coefficient.clone().divide(degree)
-            M.setLetter(letter, degree)
-        } else {
-            // There is no letter.
-
-            // The coefficient might be zero (=> x) or a number a (=> ax)
-            if (M.coefficient.isZero()) {
-                M.coefficient = new Fraction().one()
-            }
-            M.setLetter(letter, 1)
-        }
-
-        return M
-    }
-
-    public reduce = (): this => {
-        // Reduce the coefficient
-        this.coefficient.reduce()
-
-        // Reduce the literal parts (removing null powers)
-        for (const letter in this.#literal) {
-            if (this.#literal[letter].isZero()) {
-                this.removeVariable(letter)
-            }
-        }
-        return this
-    }
-
-    public removeVariable(letter: string) {
-        /* eslint-disable */
-        delete this.#literal[letter]
-        /* eslint-enable */
-    }
-
-    /**
-     * Get the nth-root of the monom
-     * @todo Not yet implemented
-     */
-    public root = (): this => {
-        // TODO: implement nth-root for monoms
-        throw new NotImplementedError('Method not implemented.')
-    }
-
-    /**
-     * Set the power of a particular setLetter
-     * @param letter (string) Letter to change
-     * @param pow (number) Power of the setLetter (must be positive integer.
-     */
-    public setLetter = (letter: string, pow: InputValue<Fraction>): this => {
-        if (!(pow instanceof Fraction)) {
-            return this.setLetter(letter, new Fraction(pow))
-        }
-
-        // Set the power of the letter to zero => remove it
-        if (this.hasVariable(letter) && pow.isZero()) {
-            this.removeVariable(letter)
-            return this
-        }
-
-
-        this.#literal[letter] = pow.clone()
-
-        return this
-    }
-
-    /**
-     * Return the square root of a monom
-     */
-    public sqrt = (): this => {
-        if (this.isSquare()) {
-            this.#coefficient.sqrt()
-            for (const letter in this.#literal) {
-                this.#literal[letter].divide(2)
-            }
-        }
-
-        // TODO: throw an error if the monom is not a square ? Or allow the result to be a monom with rational powers ?
-        return this
-    }
-
-    /**
-     * Subtract multiple monoms
-     * @param M (Monom[]) The monoms to subtract
-     */
-    public subtract = (...M: InputAlgebra<Fraction>[]): this => {
-        for (const m of M) {
-            // If the value given is not a monom, create it.
-            const mAsMonom = (!(m instanceof Monom)) ? new Monom(m) : m
-
-            if (this.isSameAs(mAsMonom)) {
-                if (this.isZero()) {
-                    this.#cloneLiteral(mAsMonom)
-                }
-
-                this.#coefficient.add(mAsMonom.clone().coefficient.opposite())
-            } else {
-                throw new MathError('Subtract: Is not similar: ' + mAsMonom.display)
-            }
-        }
-        return this
-    }
-
-    // Getter helpers.
-    /**
-     * Get the variables letters
-     */
-    public get variables(): string[] {
-        // const M = this.clone().clean()
-
-        const L: string[] = []
-        Object.entries(this.literal).forEach(
-            ([key, value]) => {
-                if (!value.isZero()) {
-                    L.push(key)
-                }
-            })
-        L.sort()
-        return L
-        // return Object.keys(M.literal)
-    }
-
-    /**
-     * Create a zero value monom
-     */
-    public zero = (): this => {
-        this.#coefficient = new Fraction().zero()
-        this.#literal = {}
-        return this
-    }
-
-    #cloneLiteral(inputStr: Monom) {
-        for (const k in inputStr.literal) {
-            this.#literal[k] = inputStr.literal[k].clone()
-        }
-    }
-
-    #evaluateAsNumeric = (values: literalType<number | Fraction> | InputValue<Fraction>): number => {
-        let r = this.coefficient.value
-
-        if (typeof values === "number") {
-            const tmpValues: literalType<number> = {}
-            const key = this.variables[0]
-            tmpValues[key] = values
-
-            return this.#evaluateAsNumeric(tmpValues)
-        }
-
-        if (values instanceof Fraction) {
-            const tmpValues: literalType<number> = {}
-            tmpValues[this.variables[0]] = new Fraction(values).value
-            return this.#evaluateAsNumeric(tmpValues)
-        }
-
-        if (typeof values === 'object') {
-            if (this.variables.length === 0) {
-                return this.coefficient.value
-            }
-
-            for (const L in this.#literal) {
-                const v = values[L]
-
-                if (v instanceof Fraction) {
-                    r *= v.value ** (this.#literal[L].value)
-                } else {
-                    r *= v ** (this.#literal[L].value)
-                }
-            }
-        }
-
-        return r
-    }
-
-    #format = (type: 'tex' | 'display' | 'plot'): string => {
-        let L = ''
-        const letters = Object.keys(this.#literal).sort()
-
-        for (const letter of letters) {
-            if (this.#literal[letter].isNotZero()) {
-                if (type === 'plot' && L !== '') { L += '*' }
-                L += letter
-                if (this.#literal[letter].isNotEqual(1)) {
-                    L += type === 'tex'
-                        ? `^{ ${this.#literal[letter].tfrac.tex} }`
-                        : `^(${this.#literal[letter].display})`
-                }
-            }
-        }
-
-        const coeffStr = type === 'tex' ? this.#coefficient.frac.tex : this.#coefficient.display
-
-        if (L === '') {
-            return this.#coefficient.value !== 0 ? coeffStr : '0'
-        }
-
-        if (this.#coefficient.value === 1) { return L }
-        if (this.#coefficient.value === -1) { return `-${L}` }
-        if (this.#coefficient.value === 0) { return '0' }
-        return type === 'plot' ? `${coeffStr}*${L}` : `${coeffStr}${L}`
-    }
-
-    #getLiteralDividers(arr: literalType<Fraction>[], letter: string): literalType<Fraction>[] {
-        const tmpList: Record<string, Fraction>[] = []
-
-        // Be default, this.literal[letter] should be a rational number.
-        for (let d = 0; d <= this.literal[letter].value; d++) {
-            if (arr.length === 0) {
-                const litt: literalType<Fraction> = {}
-                litt[letter] = new Fraction(d)
-                tmpList.push(litt)
-            } else {
-                for (const item of arr) {
-                    const litt: literalType<Fraction> = {}
-                    for (const currentLetter in item) {
-                        litt[currentLetter] = item[currentLetter]
-                    }
-                    litt[letter] = new Fraction(d)
-                    tmpList.push(litt)
-                }
-            }
-        }
-        return tmpList
-    }
-
-    #shutingYardAddToken = (stack: Monom[], element: Token): void => {
-        let q1: Monom, q2: Monom, m: Monom, letter: string, pow: Fraction
-
-        if (element.tokenType === ShutingyardType.COEFFICIENT) {
-            stack.push(new Monom(new Fraction(element.token)))
-
-        } else if (element.tokenType === ShutingyardType.VARIABLE) {
-            const M = new Monom().one()
-            M.setLetter(element.token, 1)
-            stack.push(M.clone())
-
-        } else if (element.tokenType === ShutingyardType.OPERATION) {
-            switch (element.token) {
-                case '-':
-                    // this should only happen for negative powers or for negative coefficient.
-                    q2 = (stack.pop()) ?? new Monom().zero()
-                    q1 = (stack.pop()) ?? new Monom().zero()
-
-                    stack.push(q1.subtract(q2))
-
-                    break
-                case '*':
-                    // Get the last element in the stack
-                    q2 = (stack.pop()) ?? new Monom().one()
-                    q1 = (stack.pop()) ?? new Monom().one()
-
-                    stack.push(q1.multiply(q2))
-                    break
-                case '/':
-                    // Get the last element in the stack
-                    q2 = (stack.pop()) ?? new Monom().one()
-                    q1 = (stack.pop()) ?? new Monom().one()
-
-                    stack.push(q1.divide(q2))
-                    break
-                case '^': {
-                    // get the two last elements in the stack
-                    const poppedCoefficient = stack.pop()?.coefficient
-                    pow = poppedCoefficient ?? new Fraction().one()
-                    m = stack.pop() ?? new Monom().one()
-
-                    letter = m.variables[0]
-
-                    if (letter) {
-                        m.setLetter(letter, pow)
-                    }
-
-                    stack.push(m)
-                    // this.multiply(m.clone())
-                    break
-                }
-            }
-        }
-    }
-
-    #shutingYardToReducedMonom = (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 Monom`, {cause: e})
-        }
-        const rpn: { token: string, tokenType: ShutingyardType }[] = SY.rpn
-
-        const stack: Monom[] = []
-
-        if (rpn.length === 0) {
-            this.zero()
-            return this
-        } else if (rpn.length === 1) {
-            const element = rpn[0]
-
-            this.one()
-            if (element.tokenType === ShutingyardType.COEFFICIENT) {
-                this.coefficient = new Fraction(element.token)
-            } else if (element.tokenType === ShutingyardType.VARIABLE) {
-                this.setLetter(element.token, 1)
-            }
-            return this
-        } else {
-            // Reset the monom
-            for (const element of rpn) {
-                this.#shutingYardAddToken(stack, element)
-            }
-        }
-
-        this.one()
-        this.multiply(stack[0])
-        return this
-    }
-}
+/***
+ * Monom class
+ */
+import type {
+    IAlgebra,
+    IAnalyse,
+    IExpression,
+    InputAlgebra,
+    InputValue,
+    IPiMathObject,
+    literalType
+} from "../pimath.interface"
+import {Fraction} from "../coefficients"
+import {Numeric} from "../numeric"
+
+import {ShutingYard, ShutingyardType, type Token} from "piexpression"
+import {MathError, NotImplementedError, ParseError} from "../errors"
+
+export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse<Monom>, IAlgebra<Monom> {
+    #coefficient: Fraction
+    #literal: literalType<Fraction>
+
+    constructor(value?: InputValue<Fraction>)
+    constructor(value?: Monom)
+    constructor(value?: InputAlgebra<Fraction>) {
+        this.#coefficient = new Fraction().zero()
+        this.#literal = {}
+
+        if (value !== undefined) {
+            // A string is given - try to parse the value.
+            this.parse(value)
+        }
+
+        return this
+    }
+
+    // -----------------------------------------
+    /**
+     * Parse a string to a monom. The string may include fraction.
+     * @param inputStr
+     */
+    parse(inputStr: InputAlgebra<Monom>): this {
+        // Initialize the monom
+        this.#coefficient = new Fraction()
+        this.#literal = {}
+
+        if (inputStr instanceof Monom) {
+            this.#coefficient = inputStr.#coefficient.clone()
+
+            // Copy the literal parts
+            this.#cloneLiteral(inputStr)
+            return this
+        }
+
+        if (inputStr instanceof Fraction) {
+            this.#coefficient = inputStr.clone()
+            return this
+        }
+
+        if (typeof inputStr === 'number') {
+            this.#coefficient = new Fraction(inputStr)
+            return this
+        }
+
+
+        if (!isNaN(Number(inputStr))) {
+            this.#coefficient = new Fraction(Number(inputStr))
+        } else {
+            this.#shutingYardToReducedMonom(inputStr)
+        }
+        return this
+    }
+
+    /**
+     * Clone the current Monom.
+     */
+    copy(): this {
+        throw new NotImplementedError("copy() is not yet implemented for Monom")
+    }
+
+    clone = (): Monom => {
+        const F: Monom = new Monom()
+
+        F.coefficient = this.#coefficient.clone()
+
+        // Copy the literal parts.
+        for (const k in this.#literal) {
+            F.setLetter(k, this.#literal[k].clone())
+        }
+        return F
+    }
+
+    /**
+     * Get the tex output of the monom
+     */
+    get tex(): string {
+        return this.#format('tex')
+    }
+
+    // Display getter
+    /**
+     * This display getter is to be used in the polynom display getter
+     */
+    get display(): string {
+        return this.#format('display')
+    }
+
+    static gcd = (...monoms: Monom[]): Monom => {
+        // All the monoms must be with natural powers...
+        for (const m of monoms) {
+            if (m.containsRationalPower()) {
+                return new Monom().zero()
+            }
+        }
+
+        const M = new Monom(),
+            n: number = Numeric.gcd(...monoms.map(value => value.coefficient.numerator)),
+            d: number = Numeric.lcm(...monoms.map(value => value.coefficient.denominator))
+
+        // Get the coefficient.
+        M.coefficient = new Fraction(n, d).reduce()
+
+        // Set the literal parts - go through each monoms literal parts and get only the lowest degree of each letters.
+        for (const m of monoms) {
+            // Remove the inexistant letters from the resulting monom
+            for (const letter in M.literal) {
+                if (!(letter in m.literal)) {
+                    M.removeVariable(letter)
+                }
+            }
+            for (const letter in m.literal) {
+                if (!M.hasVariable(letter) && m.literal[letter].isStrictlyPositive()) {
+                    M.literal[letter] = m.literal[letter].clone()
+                } else {
+                    M.literal[letter] = new Fraction(Math.min(m.literal[letter].value, M.literal[letter].value))
+                }
+            }
+        }
+
+        return M
+    }
+
+    /**
+     * Multiply two monoms and return a NEW monom.
+     * @param monoms
+     */
+    static xMultiply = (...monoms: Monom[]): Monom => {
+        const M = new Monom().one()
+
+        for (const m of monoms) {
+            M.multiply(m)
+        }
+
+        return M
+    }
+
+    /**
+     * Add all similar monoms. If they aren't similar, they are simply skipped.
+     * @param M (Monom[]) The monoms to add.
+     */
+    add = (...M: InputAlgebra<Fraction>[]): this => {
+        for (const m of M) {
+            // If the value given is not a monom, create it.
+            const mAsMonom = (!(m instanceof Monom)) ? new Monom(m) : m
+
+            if (this.isSameAs(mAsMonom)) {
+                if (this.isZero()) {
+                    this.#cloneLiteral(mAsMonom)
+                }
+
+                this.#coefficient.add(mAsMonom.coefficient)
+            } else {
+                throw new MathError('Add monom: ' + this.display + ' is not similar with ' +  mAsMonom.display)
+            }
+        }
+        return this
+    }
+
+    /**
+     * Get the coefficient \\(k\\) of the Monom \\(k\\cdot x^{n}\\)
+     * @returns {Fraction}
+     */
+    get coefficient(): Fraction {
+        return this.#coefficient
+    }
+
+    /**
+     * Set the coefficient \\(k\\) value of the monom
+     * @param {Fraction | number | string} F
+     */
+    set coefficient(F: InputValue<Fraction>) {
+        this.#coefficient = new Fraction(F)
+    }
+
+    containsRationalPower = (): boolean => {
+        return Object.values(this.#literal).some((value) => value.hasFractionalPart())
+    }
+
+    /**
+     * Get the degree of a monom. If no setLetter is given, the result will be the global degree.
+     * @param letter (string) Letter to get to degree (power)
+     */
+    degree = (letter?: string): Fraction => {
+        if (this.variables.length === 0) {
+            return new Fraction().zero()
+        }
+        if (letter === undefined) {
+            // Not setLetter given -> we get the global monom degree (sum of all the letters).
+            return Object.values(this.#literal).reduce((t, n) => t.clone().add(n))
+        } else {
+            // A setLetter is given -> get the corresponding power.
+            return !this.hasVariable(letter) ? new Fraction().zero() : this.#literal[letter].clone()
+        }
+    }
+
+    /**
+     * Derivative the monom
+     * @param letter
+     */
+    derivative = (letter = 'x'): Monom => {
+        // No setLetter given - assume it's the setLetter 'x'
+        if (this.hasVariable(letter)) {
+            const d = this.#literal[letter].clone(),
+                dM = this.clone()
+
+            // Subtract one to the degree.
+            dM.#literal[letter].subtract(1)
+
+            // Multiply the coefficient by the previous degree
+            dM.#coefficient.multiply(new Fraction(d.clone()))
+            return dM
+        } else {
+            return new Monom().zero()
+        }
+    }
+
+    /**
+     * Divide the current monoms by multiple monoms
+     * @param M (Monom[])
+     */
+    divide = (...M: InputAlgebra<Fraction>[]): this => {
+        // Depending on the given value, choose the current item
+        for (const m of M) {
+            // If the value given is not a monom, create it.
+            const mAsMonom = (!(m instanceof Monom)) ? new Monom(m) : m
+
+            // Divide the coefficient
+            this.#coefficient.divide(mAsMonom.coefficient)
+
+            // Subtract the power values
+            for (const letter in mAsMonom.literal) {
+
+                this.#literal[letter] = this.hasVariable(letter) ?
+                    this.#literal[letter].subtract(mAsMonom.literal[letter]) :
+                    mAsMonom.literal[letter].clone().opposite()
+
+
+                // If the power of a particular setLetter is zero, delete it from the literal part..
+                if (this.#literal[letter].isZero()) {
+                    this.removeVariable(letter)
+                }
+            }
+        }
+        return this
+    }
+
+    get dividers(): Monom[] {
+        // Decompose only if the coefficient is a natural number
+        if (!this.coefficient.isRelative()) {
+            return [this.clone()]
+        }
+
+        // Decompose only if the power values are natural numbers.
+        if (this.containsRationalPower()) {
+            return [this.clone()]
+        }
+
+        // Security : do not do this if greater than 10000
+        if (this.coefficient.numerator > 1000000) {
+            return [this.clone()]
+        }
+
+        const dividers = Numeric.dividers(Math.abs(this.coefficient.numerator))
+
+        // Decompose the literals parts.
+        let literals: literalType<Fraction>[] = []
+        for (const L in this.literal) {
+            // L is the letter.
+            literals = this.#getLiteralDividers(literals, L)
+        }
+
+        const monomDividers: Monom[] = []
+        if (literals.length > 0 && dividers.length > 0) {
+            for (const N of dividers) {
+                for (const L of literals) {
+                    const M = new Monom()
+                    M.coefficient = new Fraction(N)
+                    M.literal = L
+                    monomDividers.push(M)
+                }
+            }
+        } else if (dividers.length === 0) {
+            for (const L of literals) {
+                const M = new Monom()
+                M.coefficient = new Fraction().one()
+                M.literal = L
+                monomDividers.push(M)
+            }
+        } else {
+            for (const N of dividers) {
+                const M = new Monom()
+                M.coefficient = new Fraction(N)
+                monomDividers.push(M)
+            }
+        }
+
+        return monomDividers.length === 0 ? [new Monom().one()] : monomDividers
+    }
+
+    /**
+     * Evaluate a monom. Each setLetter must be assigned to a Fraction.
+     * @param values    Dictionary of <setLetter: Fraction>
+     * @param asNumeric
+     */
+    evaluate = (values: literalType<number | Fraction> | InputValue<Fraction>, asNumeric?: boolean): Fraction | number => {
+        // If as numeric return the numeric value
+        if (asNumeric === true) {
+            // Convert all values to numeric
+            // If the value is a Fraction, convert it to a number
+            if (values instanceof Fraction) {
+                return this.#evaluateAsNumeric(values.value)
+            }
+
+            // If the value is a number, return the numeric value
+            if (typeof values === 'number') {
+                return this.#evaluateAsNumeric(values)
+            }
+
+            // If the value is an object, return the numeric value
+            if (typeof values === 'object') {
+                // Convert {[key:string]:Fraction} to {[key:string]:number}
+                const tmpValues: literalType<number> = {}
+                for (const L in values) {
+                    tmpValues[L] = new Fraction(values[L]).value
+                }
+
+                return this.#evaluateAsNumeric(tmpValues)
+            }
+        }
+
+        // The answer must be a Fraction
+        const r = this.coefficient.clone()
+
+        if (typeof values === 'number' || values instanceof Fraction) {
+            const tmpValues: literalType<Fraction> = {}
+            tmpValues[this.variables[0]] = new Fraction(values)
+            return this.evaluate(tmpValues)
+        }
+
+        if (typeof values === 'object') {
+            if (this.variables.length === 0) {
+                return this.coefficient
+            }
+
+            for (const L in this.#literal) {
+                const value = new Fraction(values[L])
+
+                r.multiply(value.pow(this.#literal[L]))
+            }
+        }
+
+        return r
+    }
+
+    // -------------------------------------
+    /**
+     * Determine if a monom contains a setLetter in it's literal part
+     * @param letter
+     */
+    hasVariable = (letter?: string): boolean => {
+        // The letter was not found
+        return Object.hasOwn(this.#literal, letter ?? 'x')
+    }
+
+    integrate(a: InputValue<Fraction>, b: InputValue<Fraction>, letter?: string): Fraction {
+        const primitive = this.primitive(letter)
+
+        return (primitive.evaluate(b, false) as Fraction)
+            .subtract(primitive.evaluate(a, false) as Fraction)
+    }
+
+    inverse = (): this => {
+        this.#coefficient.inverse()
+        for (const letter in this.#literal) {
+            this.#literal[letter].opposite()
+        }
+        return this
+    }
+
+    isDivisible = (div: Monom): boolean => {
+        // For all variables (letters), the current monom must have a degree higher than the divider
+        if (div.degree().isStrictlyPositive()) {
+            for (const letter of div.variables) {
+                if (!this.degree(letter).isGeq(div.degree(letter))) {
+                    return false
+                }
+            }
+        }
+
+        // If the coefficient has a fractional part, we suppose we don't need to check the division by the coefficient.
+        if (this.coefficient.hasFractionalPart() || div.coefficient.hasFractionalPart()) {
+            return true
+        }
+
+        return this.coefficient.clone().divide(div.coefficient).isRelative()
+    }
+
+    /**
+     * Determine if two monoms are equals
+     * @param M
+     */
+    isEqual = (M: Monom): boolean => {
+        return this.isSameAs(M) && this.#coefficient.isEqual(M.coefficient)
+    }
+
+    isLiteralSquare = (): boolean => {
+        for (const letter in this.literal) {
+            // A literal square must have a natural power
+            if (this.literal[letter].hasFractionalPart()) {
+                return false
+            }
+
+            // The natural power must be even - if it's odd, the monom is not a square.
+            if (this.literal[letter].isOdd()) {
+                return false
+            }
+        }
+
+        return true
+    }
+
+    /**
+     * Determine if the monom is one
+     */
+    isOne = (): boolean => {
+        return this.#coefficient.value === 1 && this.variables.length === 0
+    }
+
+    /**
+     * Determine if two monoms are similar
+     * @param M
+     */
+    isSameAs = (M: Monom): boolean => {
+        // Get the list of all variables from both monoms.
+        const M1: string[] = this.variables
+        const M2: string[] = M.variables
+
+        // Get the list of all variables from both monoms.
+        const K: string[] = M1.concat(M2.filter((item) => !M1.includes(item)))
+
+        // If one of the monom is zero, it is the same than the other.
+        if (this.isZero() || M.isZero()) {
+            return true
+        }
+
+        // Both monoms has no literal part.
+        if (M1.length === 0 && M2.length === 0) {
+            return true
+        }
+
+        // Both monoms must have the same variables
+        if (M1.length !== M2.length) {
+            return false
+        }
+
+        // To _compare, both must be different from zero.
+        if (!this.isZero() && !M.isZero()) {
+            for (const key of K) {
+                // The variable is not available in one of the monom
+                if (!this.hasVariable(key) || !M.hasVariable(key)) {
+                    return false
+                }
+
+                // The variable does not have the same power in each monoms.
+                if (!this.#literal[key].isEqual(M.literal[key])) {
+                    return false
+                }
+            }
+        }
+
+        // All are positive check - the monoms are the sames.
+        return true
+    }
+
+    isSquare = (): boolean => {
+        if (!this.coefficient.isSquare()) {
+            return false
+        }
+        return this.isLiteralSquare()
+    }
+
+    /**
+     * Determine if the monom is null
+     */
+    isZero = (): boolean => {
+        return this.#coefficient.value === 0
+    }
+
+    /**
+     * Get the literal part of \\(x^{n_1}y^{n_2}\\) as dictionary \\[\\begin{array}{ll}x&=n_1\\\\y&=n_2\\end{array}\\]
+     * @returns {literalType}
+     */
+    get literal(): literalType<Fraction> {
+        return this.#literal
+    }
+
+    /**
+     * Set the literal part of the monom. Must be a dictionary {x: Fraction, y: Fraction, ...}
+     * @param {literalType<Fraction>} L
+     */
+    set literal(L: literalType<Fraction>) {
+        this.#literal = L
+    }
+
+    /**
+     * Set the literal part of the monom from a string
+     * @param inputStr  String like x^2y^3
+     */
+    set literalStr(inputStr: string) {
+        // Match all x^n
+        for (const v of [...inputStr.matchAll(/([a-z])\^([+-]?[0-9]+)/g)]) {
+            // Create the default letter entry if necessary.
+            if (!(v[1] in this.#literal)) {
+                this.#literal[v[1]] = new Fraction().zero()
+            }
+
+            // Add the new value.
+            this.#literal[v[1]].add(+v[2])
+        }
+
+        // Match all x
+        for (const v of [...inputStr.matchAll(/([a-z](?!\^))/g)]) {
+            // Match all single letters
+            if (!(v[1] in this.#literal)) {
+                this.#literal[v[1]] = new Fraction().zero()
+            }
+
+            // Add one to the value.
+            this.#literal[v[1]].add(1)
+        }
+    }
+
+    /**
+     * Multiple multiple monoms to the current monom
+     * @param M (Monom[]) The monoms to multiply to.
+     */
+    multiply = (...M: InputAlgebra<Fraction>[]): this => {
+        for (const m of M) {
+            // If the value given is not a monom, create it.
+            const mAsMonom = (!(m instanceof Monom)) ? new Monom(m) : m
+
+            // Multiply the coefficient.
+            this.#coefficient.multiply(mAsMonom.coefficient)
+
+            // Multiply the literal parts.
+            for (const letter in mAsMonom.literal) {
+                if (!this.hasVariable(letter)) {
+                    this.#literal[letter] = mAsMonom.literal[letter].clone()
+                } else {
+                    this.#literal[letter].add(mAsMonom.literal[letter])
+                }
+            }
+        }
+        return this
+    }
+
+    /**
+     * Create a one value monom
+     */
+    one = (): this => {
+        this.#coefficient = new Fraction().one()
+        this.#literal = {}
+        return this
+    }
+
+    /**
+     * Get the opposite
+     * Returns a monom.
+     */
+    opposite = (): this => {
+        this.#coefficient.opposite()
+        return this
+    }
+
+    get plotFunction(): string {
+        return this.#format('plot')
+    }
+
+    /**
+     * Get the pow of a monom.
+     * @param nb (number) : Mathematical pow
+     */
+    pow = (nb: number | Fraction): this => {
+        this.#coefficient.pow(nb)
+        for (const letter in this.#literal) {
+            this.#literal[letter].multiply(nb)
+        }
+        return this
+    }
+
+    primitive = (letter = 'x'): Monom => {
+        // Zero monom
+        const M = this.clone()
+        let degree: Fraction
+
+        if (M.hasVariable(letter)) {
+            degree = M.degree(letter).clone().add(1)
+            M.coefficient = M.coefficient.clone().divide(degree)
+            M.setLetter(letter, degree)
+        } else {
+            // There is no letter.
+
+            // The coefficient might be zero (=> x) or a number a (=> ax)
+            if (M.coefficient.isZero()) {
+                M.coefficient = new Fraction().one()
+            }
+            M.setLetter(letter, 1)
+        }
+
+        return M
+    }
+
+    reduce = (): this => {
+        // Reduce the coefficient
+        this.coefficient.reduce()
+
+        // Reduce the literal parts (removing null powers)
+        for (const letter in this.#literal) {
+            if (this.#literal[letter].isZero()) {
+                this.removeVariable(letter)
+            }
+        }
+        return this
+    }
+
+    removeVariable(letter: string) {
+        /* eslint-disable */
+        delete this.#literal[letter]
+        /* eslint-enable */
+    }
+
+    /**
+     * Get the nth-root of the monom
+     * @todo Not yet implemented
+     */
+    root = (): this => {
+        // TODO: implement nth-root for monoms
+        throw new NotImplementedError('Method not implemented.')
+    }
+
+    /**
+     * Set the power of a particular setLetter
+     * @param letter (string) Letter to change
+     * @param pow (number) Power of the setLetter (must be positive integer.
+     */
+    setLetter = (letter: string, pow: InputValue<Fraction>): this => {
+        if (!(pow instanceof Fraction)) {
+            return this.setLetter(letter, new Fraction(pow))
+        }
+
+        // Set the power of the letter to zero => remove it
+        if (this.hasVariable(letter) && pow.isZero()) {
+            this.removeVariable(letter)
+            return this
+        }
+
+
+        this.#literal[letter] = pow.clone()
+
+        return this
+    }
+
+    /**
+     * Return the square root of a monom
+     */
+    sqrt = (): this => {
+        if (this.isSquare()) {
+            this.#coefficient.sqrt()
+            for (const letter in this.#literal) {
+                this.#literal[letter].divide(2)
+            }
+        }
+
+        // TODO: throw an error if the monom is not a square ? Or allow the result to be a monom with rational powers ?
+        return this
+    }
+
+    /**
+     * Subtract multiple monoms
+     * @param M (Monom[]) The monoms to subtract
+     */
+    subtract = (...M: InputAlgebra<Fraction>[]): this => {
+        for (const m of M) {
+            // If the value given is not a monom, create it.
+            const mAsMonom = (!(m instanceof Monom)) ? new Monom(m) : m
+
+            if (this.isSameAs(mAsMonom)) {
+                if (this.isZero()) {
+                    this.#cloneLiteral(mAsMonom)
+                }
+
+                this.#coefficient.add(mAsMonom.clone().coefficient.opposite())
+            } else {
+                throw new MathError('Subtract: Is not similar: ' + mAsMonom.display)
+            }
+        }
+        return this
+    }
+
+    // Getter helpers.
+    /**
+     * Get the variables letters
+     */
+    get variables(): string[] {
+        // const M = this.clone().clean()
+
+        const L: string[] = []
+        Object.entries(this.literal).forEach(
+            ([key, value]) => {
+                if (!value.isZero()) {
+                    L.push(key)
+                }
+            })
+        L.sort()
+        return L
+        // return Object.keys(M.literal)
+    }
+
+    /**
+     * Create a zero value monom
+     */
+    zero = (): this => {
+        this.#coefficient = new Fraction().zero()
+        this.#literal = {}
+        return this
+    }
+
+    #cloneLiteral(inputStr: Monom) {
+        for (const k in inputStr.literal) {
+            this.#literal[k] = inputStr.literal[k].clone()
+        }
+    }
+
+    #evaluateAsNumeric = (values: literalType<number | Fraction> | InputValue<Fraction>): number => {
+        let r = this.coefficient.value
+
+        if (typeof values === "number") {
+            const tmpValues: literalType<number> = {}
+            const key = this.variables[0]
+            tmpValues[key] = values
+
+            return this.#evaluateAsNumeric(tmpValues)
+        }
+
+        if (values instanceof Fraction) {
+            const tmpValues: literalType<number> = {}
+            tmpValues[this.variables[0]] = new Fraction(values).value
+            return this.#evaluateAsNumeric(tmpValues)
+        }
+
+        if (typeof values === 'object') {
+            if (this.variables.length === 0) {
+                return this.coefficient.value
+            }
+
+            for (const L in this.#literal) {
+                const v = values[L]
+
+                if (v instanceof Fraction) {
+                    r *= v.value ** (this.#literal[L].value)
+                } else {
+                    r *= v ** (this.#literal[L].value)
+                }
+            }
+        }
+
+        return r
+    }
+
+    #format = (type: 'tex' | 'display' | 'plot'): string => {
+        let L = ''
+        const letters = Object.keys(this.#literal).sort()
+
+        for (const letter of letters) {
+            if (this.#literal[letter].isNotZero()) {
+                if (type === 'plot' && L !== '') { L += '*' }
+                L += letter
+                if (this.#literal[letter].isNotEqual(1)) {
+                    L += type === 'tex'
+                        ? `^{ ${this.#literal[letter].asTfrac.tex} }`
+                        : `^(${this.#literal[letter].display})`
+                }
+            }
+        }
+
+        const coeffStr = type === 'tex' ? this.#coefficient.asFrac.tex : this.#coefficient.display
+
+        if (L === '') {
+            return this.#coefficient.value !== 0 ? coeffStr : '0'
+        }
+
+        if (this.#coefficient.value === 1) { return L }
+        if (this.#coefficient.value === -1) { return `-${L}` }
+        if (this.#coefficient.value === 0) { return '0' }
+        return type === 'plot' ? `${coeffStr}*${L}` : `${coeffStr}${L}`
+    }
+
+    #getLiteralDividers(arr: literalType<Fraction>[], letter: string): literalType<Fraction>[] {
+        const tmpList: Record<string, Fraction>[] = []
+
+        // Be default, this.literal[letter] should be a rational number.
+        for (let d = 0; d <= this.literal[letter].value; d++) {
+            if (arr.length === 0) {
+                const litt: literalType<Fraction> = {}
+                litt[letter] = new Fraction(d)
+                tmpList.push(litt)
+            } else {
+                for (const item of arr) {
+                    const litt: literalType<Fraction> = {}
+                    for (const currentLetter in item) {
+                        litt[currentLetter] = item[currentLetter]
+                    }
+                    litt[letter] = new Fraction(d)
+                    tmpList.push(litt)
+                }
+            }
+        }
+        return tmpList
+    }
+
+    #shutingYardAddToken = (stack: Monom[], element: Token): void => {
+        let q1: Monom, q2: Monom, m: Monom, letter: string, pow: Fraction
+
+        if (element.tokenType === ShutingyardType.COEFFICIENT) {
+            stack.push(new Monom(new Fraction(element.token)))
+
+        } else if (element.tokenType === ShutingyardType.VARIABLE) {
+            const M = new Monom().one()
+            M.setLetter(element.token, 1)
+            stack.push(M.clone())
+
+        } else if (element.tokenType === ShutingyardType.OPERATION) {
+            switch (element.token) {
+                case '-':
+                    // this should only happen for negative powers or for negative coefficient.
+                    q2 = (stack.pop()) ?? new Monom().zero()
+                    q1 = (stack.pop()) ?? new Monom().zero()
+
+                    stack.push(q1.subtract(q2))
+
+                    break
+                case '*':
+                    // Get the last element in the stack
+                    q2 = (stack.pop()) ?? new Monom().one()
+                    q1 = (stack.pop()) ?? new Monom().one()
+
+                    stack.push(q1.multiply(q2))
+                    break
+                case '/':
+                    // Get the last element in the stack
+                    q2 = (stack.pop()) ?? new Monom().one()
+                    q1 = (stack.pop()) ?? new Monom().one()
+
+                    stack.push(q1.divide(q2))
+                    break
+                case '^': {
+                    // get the two last elements in the stack
+                    const poppedCoefficient = stack.pop()?.coefficient
+                    pow = poppedCoefficient ?? new Fraction().one()
+                    m = stack.pop() ?? new Monom().one()
+
+                    letter = m.variables[0]
+
+                    if (letter) {
+                        m.setLetter(letter, pow)
+                    }
+
+                    stack.push(m)
+                    // this.multiply(m.clone())
+                    break
+                }
+            }
+        }
+    }
+
+    #shutingYardToReducedMonom = (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 Monom`, {cause: e})
+        }
+        const rpn: { token: string, tokenType: ShutingyardType }[] = SY.rpn
+
+        const stack: Monom[] = []
+
+        if (rpn.length === 0) {
+            this.zero()
+            return this
+        } else if (rpn.length === 1) {
+            const element = rpn[0]
+
+            this.one()
+            if (element.tokenType === ShutingyardType.COEFFICIENT) {
+                this.coefficient = new Fraction(element.token)
+            } else if (element.tokenType === ShutingyardType.VARIABLE) {
+                this.setLetter(element.token, 1)
+            }
+            return this
+        } else {
+            // Reset the monom
+            for (const element of rpn) {
+                this.#shutingYardAddToken(stack, element)
+            }
+        }
+
+        this.one()
+        this.multiply(stack[0])
+        return this
+    }
+}