pimath 0.0.29 → 0.0.33

package/src/maths/algebra/polynom.ts

@@ -3,11 +3,12 @@
  */
 
 import {literalType, Monom} from './monom';
-import {Shutingyard} from '../shutingyard';
+import {Shutingyard, ShutingyardType, Token} from '../shutingyard';
 import {Numeric} from '../numeric';
-import {Random, randomPolynomConfig} from "../random";
 import {Fraction} from "../coefficients";
+import {log} from "util";
 
+export type PolynomParsingType = string|Polynom|number|Fraction|Monom
 /**
  * Polynom class can handle polynoms, reorder, resolve, ...
  * ```
@@ -16,16 +17,13 @@ import {Fraction} from "../coefficients";
  */
 export class Polynom {
     private _rawString: string;
-    private _monoms: Monom[];
-    private _factors: Polynom[];
-    private _texString: string;
 
     /**
      *
      * @param {string} polynomString (optional) Default polynom to parse on class creation
      * @param values
      */
-    constructor(polynomString?: string, ...values: unknown[]) {
+    constructor(polynomString?: PolynomParsingType, ...values: unknown[]) {
         this._monoms = [];
         this._factors = [];
         if (polynomString !== undefined) {
@@ -34,8 +32,8 @@ export class Polynom {
         return this;
     }
 
-    // ------------------------------------------
-    // Getter and setter
+    private _monoms: Monom[];
+
     // ------------------------------------------
     get monoms() {
         return this._monoms;
@@ -45,6 +43,11 @@ export class Polynom {
         this._monoms = M;
     }
 
+    // ------------------------------------------
+    // Getter and setter
+
+    private _factors: Polynom[];
+
     get factors(): Polynom[] {
         return this._factors;
     }
@@ -53,6 +56,12 @@ export class Polynom {
         this._factors = value;
     }
 
+    private _texString: string;
+
+    get texString(): string {
+        return this._texString;
+    }
+
     get texFactors(): string {
         this.factorize()
 
@@ -67,10 +76,6 @@ export class Polynom {
         return tex;
     }
 
-    get texString(): string {
-        return this._texString;
-    }
-
     get length() {
         // TODO: Must reduce the monoms list to remove the zero coefficient.
         return this._monoms.length;
@@ -115,47 +120,36 @@ export class Polynom {
         return this.variables.length;
     }
 
-    private genDisplay = (output?: string, forceSign?: boolean, wrapParentheses?: boolean): string => {
-        let P: string = '';
-
-        for (const k of this._monoms) {
-            if (k.coefficient.value === 0) {
-                continue;
-            }
-
-            P += `${(k.coefficient.sign() === 1 && (P !== '' || forceSign === true)) ? '+' : ''}${(output === 'tex') ? k.tex : k.display}`;
-        }
-
-        if (wrapParentheses === true && this.length > 1) {
-            if (output === 'tex') {
-                P = `\\left( ${P} \\right)`;
-            } else {
-                P = `(${P})`;
-            }
-        }
-
-        if (P === '') {
-            P = '0';
-        }
-        return P;
-    };
-
-
-    // ------------------------------------------
-    // Creation / parsing functions
     // ------------------------------------------
     /**
      * Parse a string to a polynom.
      * @param inputStr
      * @param values: as string, numbers or fractions
      */
-    parse = (inputStr: string, ...values: unknown[]): Polynom => {
+    parse = (inputStr: PolynomParsingType, ...values: unknown[]): Polynom => {
+        // Reset the main variables.
+        this._monoms = []
+        this._factors = []
+
+        if(typeof inputStr === 'string') {
+            return this._parseString(inputStr, ...values)
+        }else if(typeof inputStr === 'number' || inputStr instanceof Fraction || inputStr instanceof Monom){
+            this._monoms.push(new Monom(inputStr))
+        }else if(inputStr instanceof Polynom){
+            for(const m of inputStr.monoms){
+                this._monoms.push(m.clone())
+            }
+        }
 
+        return this
+    };
+
+    private _parseString(inputStr: string, ...values:unknown[]): Polynom{
         if (values === undefined || values.length === 0) {
             inputStr = '' + inputStr;
             this._rawString = inputStr;
 
-            // Parse the polynom using the shuting yard algorithm
+            // Parse the polynom using the shutting yard algorithm
             if (inputStr !== '' && !isNaN(Number(inputStr))) {
                 this.empty();
                 // It's a simple number.
@@ -201,52 +195,11 @@ export class Polynom {
         } else {
             return this.zero();
         }
+    }
 
-    };
-
-    /**
-     * Main parse using a shutting yard class
-     * @param inputStr
-     */
-    private shutingYardToReducedPolynom = (inputStr: string): Polynom => {
-        // Get the RPN array of the current expression
-        const SY: Shutingyard = new Shutingyard().parse(inputStr);
-        const rpn: { token: string, tokenType: string }[] = SY.rpn;
-        let m1: Polynom;
-        let m2: Polynom;
-
-        let stack: Polynom[] = [],
-            previousToken: string = null,
-            tempPolynom
-
-        for (const element of rpn) {
-            if (element.tokenType === 'coefficient' || element.tokenType === 'variable') {
-                tempPolynom = new Polynom().zero();
-                tempPolynom.monoms = [new Monom(element.token)]
-                stack.push(tempPolynom.clone())
-            } else if (element.tokenType === 'operation') {
-                m2 = (stack.pop()) || new Polynom().zero();
-                m1 = (stack.pop()) || new Polynom().zero();
-                switch (element.token) {
-                    case '+':
-                        stack.push(m1.add(m2))
-                        break;
-                    case '-':
-                        stack.push(m1.subtract(m2))
-                        break;
-                    case '*':
-                        stack.push(m1.multiply(m2))
-                        break;
-                    case '^':
-                        stack.push(m1.pow(+previousToken))
-                }
-            }
-            previousToken = element.token;
-        }
 
-        this._monoms = stack[0].monoms;
-        return this;
-    }
+    // ------------------------------------------
+    // Creation / parsing functions
 
     /**
      * Clone the polynom
@@ -287,6 +240,29 @@ export class Polynom {
         return this;
     };
 
+    // ------------------------------------------
+    opposed = (): Polynom => {
+        this._monoms = this._monoms.map(m => m.opposed());
+        return this;
+    };
+
+    add = (...values: unknown[]): Polynom => {
+
+        for (let value of values) {
+            if (value instanceof Polynom) {
+                this._monoms = this._monoms.concat(value.monoms);
+            } else if (value instanceof Monom) {
+                this._monoms.push(value.clone());
+            } else if (Number.isSafeInteger(value)) {
+                this._monoms.push(new Monom(value.toString()));
+            } else {
+                this._monoms.push(new Monom(value));
+            }
+        }
+
+        return this.reduce();
+    };
+
     // // -----------------------------------------------
     // // Polynom generators and randomizers
     // // -----------------------------------------------
@@ -351,28 +327,6 @@ export class Polynom {
 
     // ------------------------------------------
     // Mathematical operations
-    // ------------------------------------------
-    opposed = (): Polynom => {
-        this._monoms = this._monoms.map(m => m.opposed());
-        return this;
-    };
-
-    add = (...values: unknown[]): Polynom => {
-
-        for (let value of values) {
-            if (value instanceof Polynom) {
-                this._monoms = this._monoms.concat(value.monoms);
-            } else if (value instanceof Monom) {
-                this._monoms.push(value.clone());
-            } else if (Number.isSafeInteger(value)) {
-                this._monoms.push(new Monom(value.toString()));
-            } else {
-                this._monoms.push(new Monom(value));
-            }
-        }
-
-        return this.reduce();
-    };
 
     subtract = (...values: unknown[]): Polynom => {
 
@@ -398,7 +352,7 @@ export class Polynom {
             return this.multiplyByFraction(value);
         } else if (value instanceof Monom) {
             return this.multiplyByMonom(value);
-        } else if (Number.isSafeInteger(value) && typeof value==='number') {
+        } else if (Number.isSafeInteger(value) && typeof value === 'number') {
             return this.multiplyByInteger(value);
         }
 
@@ -406,37 +360,6 @@ export class Polynom {
         return this;
     }
 
-    private multiplyByPolynom = (P: Polynom): Polynom => {
-        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();
-    };
-
-    private multiplyByFraction = (F: Fraction): Polynom => {
-        for (const m of this._monoms) {
-            m.coefficient.multiply(F);
-        }
-
-        return this.reduce();
-    };
-
-    private multiplyByInteger = (nb: number): Polynom => {
-        return this.multiplyByFraction(new Fraction(nb));
-    };
-
-    private multiplyByMonom = (M: Monom): Polynom => {
-        for (const m of this._monoms) {
-            m.multiply(M)
-        }
-        return this.reduce();
-    };
-
     /**
      * Divide the current polynom by another polynom.
      * @param P
@@ -476,31 +399,19 @@ export class Polynom {
             reminder.subtract(P.clone().multiply(newM));
         }
 
+        quotient.reduce()
+        reminder.reduce()
         return {quotient, reminder};
     };
 
     divide = (value: unknown): Polynom => {
         if (value instanceof Fraction) {
-            this.divideByFraction(value);
-        } else if (typeof value==='number' && Number.isSafeInteger(value)) {
+            return this.divideByFraction(value);
+        } else if (typeof value === 'number' && Number.isSafeInteger(value)) {
             return this.divideByInteger(value);
         }
-    }
-
-    private divideByInteger = (nb: number): Polynom => {
-        const nbF = new Fraction(nb);
-        for (const m of this._monoms) {
-            m.coefficient.divide(nbF);
-        }
-        return this;
-    };
 
-    private divideByFraction = (F: Fraction): Polynom => {
-        for (const m of this._monoms) {
-            m.coefficient.divide(F);
-        }
-        return this;
-    };
+    }
 
     pow = (nb: number): Polynom => {
         if (!Number.isSafeInteger(nb)) {
@@ -520,9 +431,6 @@ export class Polynom {
         return this.reduce();
     };
 
-
-    // ------------------------------------------
-    // Compare functions
     // ------------------------------------------
     /**
      * Compare the current coefficient with another coefficient
@@ -686,8 +594,11 @@ export class Polynom {
         // TODO: Maybe it's enough to just make this test !
         return polynomStringNormalized === P.reduce().reorder().display
     }
+
+
     // ------------------------------------------
-    // Misc polynoms functions
+    // Compare functions
+
     // -------------------------------------
     reduce = (): Polynom => {
         for (let i = 0; i < this._monoms.length; i++) {
@@ -777,6 +688,7 @@ export class Polynom {
             //console.log('Evaluate polynom: ', monom.display, values, monom.evaluate(values).display);
             r.add(monom.evaluate(values));
         });
+
         return r;
     };
 
@@ -798,6 +710,8 @@ export class Polynom {
         }
         return dP
     }
+    // ------------------------------------------
+    // Misc polynoms functions
 
     integrate = (a: Fraction | number, b: Fraction | number, letter?: string): Fraction => {
         const primitive = this.primitive(letter)
@@ -813,8 +727,7 @@ export class Polynom {
 
         return primitive.evaluate(valuesB).subtract(primitive.evaluate(valuesA))
     }
-    // ------------------------------------------
-    // Polynoms factorization functions
+
     // -------------------------------------
     /**
      * Factorize a polynom and store the best results in factors.
@@ -827,6 +740,7 @@ export class Polynom {
         let P = this.clone().reorder(),
             M = P.commonMonom(),
             tempPolynom: Polynom
+
         // It has a common monom.
         if (!M.isOne()) {
             tempPolynom = new Polynom()
@@ -837,10 +751,10 @@ export class Polynom {
 
         let securityLoop = P.degree().clone().multiply(2).value
         // securityLoop = 0
+
         while (securityLoop >= 0) {
             securityLoop--
 
-
             if (P.monoms.length < 2) {
                 if (!P.isOne()) {
                     factors.push(P.clone());
@@ -851,9 +765,6 @@ export class Polynom {
                 let m1 = P.monoms[0].dividers,
                     m2 = P.monoms[P.monoms.length - 1].dividers
 
-                // console.log('CURRENT VALUE')
-                // console.log(P.tex)
-                // console.log('---------------------')
                 for (let m1d of m1) {
                     for (let m2d of m2) {
                         // if(m1d.degree()===m2d.degree()){continue}
@@ -862,7 +773,6 @@ export class Polynom {
                         dividerPolynom.monoms = [m1d.clone(), m2d.clone()]
                         result = P.euclidian(dividerPolynom)
 
-                        // console.log(dividerPolynom.tex, '=>', result.reminder.tex, '|||||', result.quotient.tex)
                         if (result.reminder.isZero()) {
                             P = result.quotient.clone();
                             factors.push(dividerPolynom)
@@ -875,172 +785,40 @@ export class Polynom {
                             P = result.quotient.clone();
                             factors.push(dividerPolynom)
                         }
-                        // console.log(dividerPolynom.tex, '=>', result.reminder.tex)
                     }
                 }
             }
-
         }
 
         this.factors = factors
         return factors;
     }
 
-    private _factorize2ndDegree = (letter: string): Polynom[] => {
-        let P1: Polynom, P2: Polynom,
-            a, b, c, delta, x1, x2, factor;
-
-        // One variable only
-        if (this.numberOfVars === 1) {
-            a = this.monomByDegree(2, letter).coefficient;
-            b = this.monomByDegree(1, letter).coefficient;
-            c = this.monomByDegree(0, letter).coefficient;
-            delta = b.clone().pow(2).subtract(a.clone().multiply(c).multiply(4));
-
-            if (delta.isZero()) {
-                x1 = b.clone().opposed().divide(a.clone().multiply(2))
-                P1 = new Polynom(letter).subtract(x1.display).multiply(x1.denominator)
-                P2 = new Polynom(letter).subtract(x1.display).multiply(x1.denominator)
-                factor = a.divide(x1.denominator).divide(x1.denominator);
+    // TODO: get zeroes for more than first degree and for more than natural degrees
+    getZeroes = (): (Fraction | boolean)[] => {
+        const Z: Fraction[] = [];
 
-                if (!factor.isOne()) {
-                    // TODO: Update new Polynom to accept anything...
-                    return [new Polynom(factor.display), P1, P2]
+        switch (this.degree().value) {
+            case 0:
+                if (this._monoms[0].coefficient.value === 0) {
+                    return [true];
                 } else {
-                    return [P1, P2]
-                }
-            } else if (delta.isPositive() && delta.isSquare()) {
-                x1 = b.clone().opposed()
-                    .add(delta.clone().sqrt())
-                    .divide(a.clone().multiply(2))
-                x2 = b.clone().opposed()
-                    .subtract(delta.clone().sqrt())
-                    .divide(a.clone().multiply(2))
-
-                // (2x+5)(3x-2)
-                // 6x^2+11x-10
-                // a = 6, b = 11, c = -10
-                // delta = 121-4*6*(-10) = 361= 19^2
-                // x1 = (-11 + 19)  / 12 = 8/12 = 2/3
-                // x2 = (-11 - 19)  / 12 = -30/12 = -5/2
-                factor = a.divide(x1.denominator).divide(x2.denominator);
-                if (factor.isOne()) {
-                    return [
-                        new Polynom(letter).subtract(x1.display).multiply(x1.denominator),
-                        new Polynom(letter).subtract(x2.display).multiply(x2.denominator),
-                    ]
-                } else {
-                    return [
-                        new Polynom(factor.display),
-                        new Polynom(letter).subtract(x1.display).multiply(x1.denominator),
-                        new Polynom(letter).subtract(x2.display).multiply(x2.denominator),
-                    ]
-
-                }
-            } else {
-                // No solution possible - return the complete value.
-                return [this.clone()]
-            }
-        } else {
-            // If multiple variables, only handle perfect squares...
-            a = this.monomByDegree(2, letter);
-            b = this.monomByDegree(1, letter);
-            c = this.monomByDegree(0, letter);
-
-
-            if (a.isLiteralSquare() && c.isLiteralSquare()) {
-                // Check the middle item is same as...
-                if (b.clone().pow(2).isSameAs(a.clone().multiply(c))) {
-                    // Determine if the coefficient values matches.
-
-                    // Search 4 values (r, s, t, u) that matches:
-                    // (r X + s Y)(t X + u Y) = rt X^2 + (ru + st) XY + su Y^2
-
-                    let xPolynom = new Polynom('x', a.coefficient, b.coefficient, c.coefficient);
-                    let xFactors = xPolynom._factorize2ndDegree('x');
-
-                    let factors = [], xyzPolynom: Polynom;
-
-                    if (xFactors.length >= 2) {
-                        for (let p of xFactors) {
-                            if (p.degree().isZero()) {
-                                factors.push(p.clone())
-                            } else {
-                                xyzPolynom = p.clone();
-                                xyzPolynom.monoms[0].literal = a.literalSqrt
-                                xyzPolynom.monoms[1].literal = c.literalSqrt
-                                factors.push(xyzPolynom.clone())
-                            }
-                        }
-                        return factors
-                    }
-                }
-            }
-
-            return [this.clone()]
-            //
-            // console.log(a.tex, b.tex, c.tex)
-            // if (a.isSquare() && c.isSquare()) {
-            //     console.log('A C squares')
-            //     if (a.clone().sqrt().multiply(c.clone().sqrt()).multiplyByNumber(2).isSameAs(b)) {
-            //         console.log('HERE')
-            //         if (a.coefficient.sign() === b.coefficient.sign()) {
-            //             return []
-            //         }else{
-            //             return []
-            //         }
-            //     }
-            // } else if(a.isLiteralSquare() && c.isLiteralSquare()) {
-            //     console.log('A C litteral SQUARES')
-            //     // Check that the middle element is the product of a and c.
-            //
-            //     if(b.clone().pow(2).isSameAs(a.clone().multiply(c))){
-            //         console.log('SAME')
-            //
-            //     }else{
-            //         console.log('NOT SAME')
-            //     }
-            //
-            //     return [this.clone()]
-            // } else {
-            //     console.log('NOT SQUARES AT ALL !!!!')
-            // }
-
-        }
-    }
-
-    private _factorizeByGroups = (): Polynom[] => {
-        // TODO: Factorize by groups.
-        return [];
-    }
-    // ------------------------------------------
-    // Polynoms helpers functions
-    // -------------------------------------
-    // TODO: get zeroes for more than first degree and for more than natural degrees
-    getZeroes = (): (Fraction | boolean)[] => {
-        const Z: Fraction[] = [];
-
-        switch (this.degree().value) {
-            case 0:
-                if (this._monoms[0].coefficient.value === 0) {
-                    return [true];
-                } else {
-                    return [false];
-                }
-            case 1:
-                // There is only one monoms,
-                if (this._monoms.length === 1) {
-                    return [new Fraction().zero()];
-                } else {
-                    const P = this.clone().reduce().reorder();
-                    return [P.monoms[1].coefficient.opposed().divide(P.monoms[0].coefficient)];
-                }
-            // TODO: Determine the zeros of an equation of second degree.
-            //case 2:
-            default:
-                // Make sure the polynom is factorized.
-                if (this._factors.length === 0) {
-                    this.factorize()
+                    return [false];
+                }
+            case 1:
+                // There is only one monoms,
+                if (this._monoms.length === 1) {
+                    return [new Fraction().zero()];
+                } else {
+                    const P = this.clone().reduce().reorder();
+                    return [P.monoms[1].coefficient.opposed().divide(P.monoms[0].coefficient)];
+                }
+            // TODO: Determine the zeros of an equation of second degree.
+            //case 2:
+            default:
+                // Make sure the polynom is factorized.
+                if (this._factors.length === 0) {
+                    this.factorize()
                 }
 
                 let zeroes = [], zeroesAsTex = [];
@@ -1085,9 +863,8 @@ export class Polynom {
         return Z;
     };
 
-
     // TODO: analyse the next functions to determine if they are useful or not...
-    monomByDegree = (degree?: Fraction|number, letter?: string): Monom => {
+    monomByDegree = (degree?: Fraction | number, letter?: string): Monom => {
         if (degree === undefined) {
             // return the highest degree monom.
             return this.monomByDegree(this.degree(letter), letter);
@@ -1105,7 +882,7 @@ export class Polynom {
         return new Monom().zero();
     };
 
-    monomsByDegree = (degree?: number|Fraction, letter?: string): Monom[] => {
+    monomsByDegree = (degree?: number | Fraction, letter?: string): Monom[] => {
         if (degree === undefined) {
             // return the highest degree monom.
             return this.monomsByDegree(this.degree(letter));
@@ -1137,7 +914,6 @@ export class Polynom {
         return new Monom().zero();
     };
 
-
     // Next functions are used for for commonMonom, which is used in the factorize method.
     getDenominators = (): number[] => {
         const denominators: number[] = [];
@@ -1158,6 +934,8 @@ export class Polynom {
     lcmDenominator = (): number => {
         return Numeric.lcm(...this.getDenominators());
     };
+    // ------------------------------------------
+    // Polynoms factorization functions
 
     gcdDenominator = (): number => {
         return Numeric.gcd(...this.getDenominators());
@@ -1170,6 +948,9 @@ export class Polynom {
     gcdNumerator = (): number => {
         return Numeric.gcd(...this.getNumerators());
     };
+    // ------------------------------------------
+    // Polynoms helpers functions
+    // -------------------------------------
 
     commonMonom = (): Monom => {
         let M = new Monom().one(), numerator: number, denominator: number, degree = this.degree();
@@ -1190,4 +971,341 @@ export class Polynom {
         }
         return M;
     }
+
+    private genDisplay = (output?: string, forceSign?: boolean, wrapParentheses?: boolean): string => {
+        let P: string = '';
+
+        for (const k of this._monoms) {
+            if (k.coefficient.value === 0) {
+                continue;
+            }
+
+            P += `${(k.coefficient.sign() === 1 && (P !== '' || forceSign === true)) ? '+' : ''}${(output === 'tex') ? k.tex : k.display}`;
+        }
+
+        if (wrapParentheses === true && this.length > 1) {
+            if (output === 'tex') {
+                P = `\\left( ${P} \\right)`;
+            } else {
+                P = `(${P})`;
+            }
+        }
+
+        if (P === '') {
+            P = '0';
+        }
+        return P;
+    };
+
+
+    static addToken = (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:
+                // TODO: add constant support to Polynom parsing.
+                console.log('Actually, not supported - will be added later !')
+                break
+
+            case ShutingyardType.OPERATION:
+                if(stack.length>=2){
+                    const b = stack.pop(),
+                        a = stack.pop()
+
+                    if(element.token === '+'){
+                        stack.push(a.add(b))
+                    }else if(element.token === '-'){
+                        stack.push(a.subtract(b))
+                    }else if(element.token === '*'){
+                        stack.push(a.multiply(b))
+                    }else if(element.token === '/'){
+                        if(b.degree().isStrictlyPositive()){
+                            console.log('divide by a polynom -> should create a rational polynom !')
+                        }else {
+                            stack.push(a.divide(b.monoms[0].coefficient))
+
+                        }
+                    }else if(element.token === '^'){
+                        if(b.degree().isStrictlyPositive()) {
+                            console.error('Cannot elevate a polynom with another polynom !')
+                        }else {
+                            if(b.monoms[0].coefficient.isRelative()) {
+                                // Integer power
+                                stack.push(a.pow(b.monoms[0].coefficient.value))
+                            }else{
+                                // Only allow power if the previous polynom is only a monom, without coefficient.
+                                if(a.monoms.length===1 && a.monoms[0].coefficient.isOne()){
+                                    for (let letter in a.monoms[0].literal) {
+                                        a.monoms[0].literal[letter].multiply(b.monoms[0].coefficient)
+                                    }
+                                    stack.push(a)
+                                }else {
+                                    console.error('Cannot have power with fraction')
+                                }
+                            }
+                        }
+                    }
+                }else{
+                    console.log('Stack size: ', stack.length)
+                    if(element.token === '-'){
+                        stack.push(stack.pop().opposed())
+                    }else{
+                        console.log('While parsing, cannot apply ', element.token, 'to', stack[0].tex)
+                    }
+                }
+                break
+
+            case ShutingyardType.MONOM:
+                // Should never appear.
+                console.error('The monom token should not appear here')
+                break;
+
+            case ShutingyardType.FUNCTION:
+                // Should never appear.
+                console.log('The function token should not appear here - might be introduced later.')
+                break;
+        }
+    }
+    /**
+     * Main parse using a shutting yard class
+     * @param inputStr
+     */
+    private shutingYardToReducedPolynom = (inputStr: string): Polynom => {
+        // Get the RPN array of the current expression
+        const SY: Shutingyard = new Shutingyard().parse(inputStr);
+        const rpn: { token: string, tokenType: string }[] = SY.rpn;
+
+        // New version for reducing shuting yard.
+        this.zero()
+
+        let stack: Polynom[] = [],
+            monom: Monom = new Monom()
+
+        // Loop through the
+        for (const element of rpn) {
+            Polynom.addToken(stack, element);
+        }
+
+        if (stack.length === 1) {
+            this.add(stack[0])
+        }
+
+        return this
+        /**
+         let m1: Polynom;
+         let m2: Polynom;
+
+         let stack: Polynom[] = [],
+         previousToken: string = null,
+         tempPolynom
+
+         for (const element of rpn) {
+            if (element.tokenType === 'coefficient' || element.tokenType === 'variable') {
+                tempPolynom = new Polynom().zero();
+                tempPolynom.monoms = [new Monom(element.token)]
+                stack.push(tempPolynom.clone())
+            } else if (element.tokenType === 'operation') {
+                m2 = (stack.pop()) || new Polynom().zero();
+                m1 = (stack.pop()) || new Polynom().zero();
+                switch (element.token) {
+                    case '+':
+                        stack.push(m1.add(m2))
+                        break;
+                    case '-':
+                        stack.push(m1.subtract(m2))
+                        break;
+                    case '*':
+                        stack.push(m1.multiply(m2))
+                        break;
+                    case '^':
+                        stack.push(m1.pow(+previousToken))
+                }
+            }
+            previousToken = element.token;
+        }
+
+         this._monoms = stack[0].monoms;
+         return this;*/
+    }
+
+    private multiplyByPolynom = (P: Polynom): Polynom => {
+        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();
+    };
+
+    private multiplyByFraction = (F: Fraction): Polynom => {
+        for (const m of this._monoms) {
+            m.coefficient.multiply(F);
+        }
+
+        return this.reduce();
+    };
+
+    private multiplyByInteger = (nb: number): Polynom => {
+        return this.multiplyByFraction(new Fraction(nb));
+    };
+
+    private multiplyByMonom = (M: Monom): Polynom => {
+        for (const m of this._monoms) {
+            m.multiply(M)
+        }
+        return this.reduce();
+    };
+
+    private divideByInteger = (nb: number): Polynom => {
+        const nbF = new Fraction(nb);
+        for (const m of this._monoms) {
+            m.coefficient.divide(nbF);
+        }
+        return this;
+    };
+
+    private divideByFraction = (F: Fraction): Polynom => {
+        for (const m of this._monoms) {
+            m.coefficient.divide(F);
+        }
+        return this;
+    };
+
+    private _factorize2ndDegree = (letter: string): Polynom[] => {
+        let P1: Polynom, P2: Polynom,
+            a, b, c, delta, x1, x2, factor;
+
+        // One variable only
+        if (this.numberOfVars === 1) {
+            a = this.monomByDegree(2, letter).coefficient;
+            b = this.monomByDegree(1, letter).coefficient;
+            c = this.monomByDegree(0, letter).coefficient;
+            delta = b.clone().pow(2).subtract(a.clone().multiply(c).multiply(4));
+
+            if (delta.isZero()) {
+                x1 = b.clone().opposed().divide(a.clone().multiply(2))
+                P1 = new Polynom(letter).subtract(x1.display).multiply(x1.denominator)
+                P2 = new Polynom(letter).subtract(x1.display).multiply(x1.denominator)
+                factor = a.divide(x1.denominator).divide(x1.denominator);
+
+                if (!factor.isOne()) {
+                    // TODO: Update new Polynom to accept anything...
+                    return [new Polynom(factor.display), P1, P2]
+                } else {
+                    return [P1, P2]
+                }
+            } else if (delta.isPositive() && delta.isSquare()) {
+                x1 = b.clone().opposed()
+                    .add(delta.clone().sqrt())
+                    .divide(a.clone().multiply(2))
+                x2 = b.clone().opposed()
+                    .subtract(delta.clone().sqrt())
+                    .divide(a.clone().multiply(2))
+
+                // (2x+5)(3x-2)
+                // 6x^2+11x-10
+                // a = 6, b = 11, c = -10
+                // delta = 121-4*6*(-10) = 361= 19^2
+                // x1 = (-11 + 19)  / 12 = 8/12 = 2/3
+                // x2 = (-11 - 19)  / 12 = -30/12 = -5/2
+                factor = a.divide(x1.denominator).divide(x2.denominator);
+                if (factor.isOne()) {
+                    return [
+                        new Polynom(letter).subtract(x1.display).multiply(x1.denominator),
+                        new Polynom(letter).subtract(x2.display).multiply(x2.denominator),
+                    ]
+                } else {
+                    return [
+                        new Polynom(factor.display),
+                        new Polynom(letter).subtract(x1.display).multiply(x1.denominator),
+                        new Polynom(letter).subtract(x2.display).multiply(x2.denominator),
+                    ]
+
+                }
+            } else {
+                // No solution possible - return the complete value.
+                return [this.clone()]
+            }
+        } else {
+            // If multiple variables, only handle perfect squares...
+            a = this.monomByDegree(2, letter);
+            b = this.monomByDegree(1, letter);
+            c = this.monomByDegree(0, letter);
+
+
+            if (a.isLiteralSquare() && c.isLiteralSquare()) {
+                // Check the middle item is same as...
+                if (b.clone().pow(2).isSameAs(a.clone().multiply(c))) {
+                    // Determine if the coefficient values matches.
+
+                    // Search 4 values (r, s, t, u) that matches:
+                    // (r X + s Y)(t X + u Y) = rt X^2 + (ru + st) XY + su Y^2
+
+                    let xPolynom = new Polynom('x', a.coefficient, b.coefficient, c.coefficient);
+                    let xFactors = xPolynom._factorize2ndDegree('x');
+
+                    let factors = [], xyzPolynom: Polynom;
+
+                    if (xFactors.length >= 2) {
+                        for (let p of xFactors) {
+                            if (p.degree().isZero()) {
+                                factors.push(p.clone())
+                            } else {
+                                xyzPolynom = p.clone();
+                                xyzPolynom.monoms[0].literal = a.literalSqrt
+                                xyzPolynom.monoms[1].literal = c.literalSqrt
+                                factors.push(xyzPolynom.clone())
+                            }
+                        }
+                        return factors
+                    }
+                }
+            }
+
+            return [this.clone()]
+            //
+            // console.log(a.tex, b.tex, c.tex)
+            // if (a.isSquare() && c.isSquare()) {
+            //     console.log('A C squares')
+            //     if (a.clone().sqrt().multiply(c.clone().sqrt()).multiplyByNumber(2).isSameAs(b)) {
+            //         console.log('HERE')
+            //         if (a.coefficient.sign() === b.coefficient.sign()) {
+            //             return []
+            //         }else{
+            //             return []
+            //         }
+            //     }
+            // } else if(a.isLiteralSquare() && c.isLiteralSquare()) {
+            //     console.log('A C litteral SQUARES')
+            //     // Check that the middle element is the product of a and c.
+            //
+            //     if(b.clone().pow(2).isSameAs(a.clone().multiply(c))){
+            //         console.log('SAME')
+            //
+            //     }else{
+            //         console.log('NOT SAME')
+            //     }
+            //
+            //     return [this.clone()]
+            // } else {
+            //     console.log('NOT SQUARES AT ALL !!!!')
+            // }
+
+        }
+    }
+
+    private _factorizeByGroups = (): Polynom[] => {
+        // TODO: Factorize by groups.
+        return [];
+    }
 }