pimath 0.0.49 → 0.0.53

package/src/maths/algebra/equation.ts

@@ -2,22 +2,28 @@ import {Polynom} from "./polynom";
 import {literalType, Monom} from "./monom";
 import {Numeric} from "../numeric";
 import {Fraction} from "../coefficients/fraction";
-import {Nthroot} from "../coefficients/nthroot";
+import {NthRoot} from "../coefficients/nthRoot";
 
 /**
  * Equation is a class to manage equations...
  */
-interface ISolution {
+export interface ISolution {
     tex: string,
     value: number,
     exact: unknown
 }
 
+export enum PARTICULAR_SOLUTION {
+    real="\\mathbb{R}",
+    varnothing="\\varnothing"
+}
+
 export class Equation {
     private _polynom: Polynom;  // Used to solve the equation // TODO: remove the private value ?
+
     // Undetermined texSolutions.
-    private _varnothing: string = '\\varnothing';
-    private _real: string = '\\mathbb{R}';
+    private _varnothing: string = PARTICULAR_SOLUTION.varnothing;
+    private _real: string = PARTICULAR_SOLUTION.real;
 
     /**
      * Create an Equation using two polynoms.
@@ -159,6 +165,9 @@ export class Equation {
         return this.variables.length;
     }
 
+    hasVariable = (letter: string): boolean => {
+        return this.variables.includes(letter)
+    }
 
     // ------------------------------------------
     // Creation / parsing functions
@@ -397,9 +406,29 @@ export class Equation {
             default:
                 this._solveDegree3plus();
         }
+
+        // cleanup the solutions.
+        this._solutions = Equation.makeSolutionsUnique(this._solutions)
         return this;
     };
 
+    static makeSolutionsUnique(solutions: ISolution[], sorted?: boolean):ISolution[] {
+        let solutionAsTex:string[] = [],
+            uniqueSolutions = solutions.filter(sol=>{
+                if(!solutionAsTex.includes(sol.tex)){
+                    solutionAsTex.push(sol.tex)
+                    return true
+                }else{
+                    return false
+                }
+            })
+
+        if(sorted===true){
+            uniqueSolutions.sort((a, b)=>a.value-b.value)
+        }
+        return uniqueSolutions
+    }
+
     test = (values: literalType): Boolean => {
         return this.left.evaluate(values).isEqual(this.right.evaluate(values))
     }
@@ -526,12 +555,13 @@ export class Equation {
                 }
             } else {
                 this._solutions = [{
-                    tex: v.display,
+                    tex: v.tex,
                     value: v.value,
                     exact: v
                 }]
             }
-        } else {
+        }
+        else {
             if (m1.value === 0) {
                 // In this case, the coefficient of the x variable is zero.
                 if (m0.value === 0 && this.isAlsoEqual()) {
@@ -565,7 +595,7 @@ export class Equation {
         let aF = this._polynom.monomByDegree(2, letter).coefficient,
             bF = this._polynom.monomByDegree(1, letter).coefficient,
             cF = this._polynom.monomByDegree(0, letter).coefficient,
-            delta: number, nthDelta: Nthroot,
+            delta: number, nthDelta: NthRoot,
             lcm = Numeric.lcm(aF.denominator, bF.denominator, cF.denominator),
             a = aF.multiply(lcm).value,
             b = bF.multiply(lcm).value,
@@ -594,7 +624,7 @@ export class Equation {
                     }
                 ]
             } else {
-                nthDelta = new Nthroot(delta).reduce();
+                nthDelta = new NthRoot(delta).reduce();
                 if (nthDelta.hasRadical()) {
                     // -b +- coeff\sqrt{radical}
                     // -------------------------
@@ -622,12 +652,12 @@ export class Equation {
                         } else {
                             this._solutions = [
                                 {
-                                    tex: `\\dfrac{${-b / gcd} - ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                    tex: `\\frac{${-b / gcd} - ${nthDelta.tex} }{ ${2 * a / gcd} }`,
                                     value: realX1,
                                     exact: false
                                 },
                                 {
-                                    tex: `\\dfrac{${-b / gcd} + ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                    tex: `\\frac{${-b / gcd} + ${nthDelta.tex} }{ ${2 * a / gcd} }`,
                                     value: realX2,
                                     exact: false
                                 },
@@ -650,12 +680,12 @@ export class Equation {
                         } else {
                             this._solutions = [
                                 {
-                                    tex: `\\dfrac{- ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                    tex: `\\frac{- ${nthDelta.tex} }{ ${2 * a / gcd} }`,
                                     value: realX1,
                                     exact: false
                                 },
                                 {
-                                    tex: `\\dfrac{${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                                    tex: `\\frac{${nthDelta.tex} }{ ${2 * a / gcd} }`,
                                     value: realX2,
                                     exact: false
                                 },
@@ -668,12 +698,12 @@ export class Equation {
                         S2 = new Fraction(-b + nthDelta.coefficient, 2 * a).reduce()
                     this._solutions = [
                         {
-                            tex: S1.dfrac,
+                            tex: S1.frac,
                             value: realX1,
                             exact: S1
                         },
                         {
-                            tex: S2.dfrac,
+                            tex: S2.frac,
                             value: realX2,
                             exact: S2
                         }
@@ -684,7 +714,7 @@ export class Equation {
         } else if (delta === 0) {
             const sol = new Fraction(-b, 2 * a).reduce()
             this._solutions = [{
-                tex: sol.dfrac,
+                tex: sol.frac,
                 value: sol.value,
                 exact: sol
             }];
@@ -696,7 +726,6 @@ export class Equation {
             }];
         }
 
-
         // Handle now the inequations.
         if (!this.isStrictEqual()) {
             if (this._solutions.length === 2) {
@@ -763,9 +792,29 @@ export class Equation {
         return this._solutions;
     };
 
-    private _solveDegree3plus = (): ISolution[] => {
-        // TODO: try to resolve equations with a degree superior than 2.
-        this._solutions = [{tex: 'solve x - not yet handled', value: NaN, exact: false}];  // ESLint remove system :(
+    private _solveDegree3plus = (letter?: string): ISolution[] => {
+        // Push everything to the left
+        // factorize
+        // solve each factors.
+        let equ = this.clone().moveLeft()
+        equ.left.factorize()
+
+        this._solutions = []
+
+        equ.left.factors.forEach(factor=>{
+            if(factor.degree(letter).leq(2)) {
+                let factorAsEquation = new Equation(factor, 0)
+                factorAsEquation.solve()
+                factorAsEquation.solutions.forEach(solution => {
+                    this._solutions.push(solution)
+                })
+            }else{
+                console.log(factor.tex, ': cannot actually get the solution of this equation')
+            }
+        })
+
+        // TODO: check equation resolution for more than degree 2
+        // this._solutions = [{tex: 'solve x - not yet handled', value: NaN, exact: false}];  // ESLint remove system :(
         return this._solutions;
     };
 }

package/src/maths/algebra/linearSystem.ts

@@ -118,7 +118,7 @@ export class LinearSystem {
                 return;
             }
 
-            tex.push(this._solutions[letter].value.dfrac);
+            tex.push(this._solutions[letter].value.frac);
         }
         return `(${tex.join(';')})`;
     }

package/src/maths/algebra/monom.ts

@@ -2,8 +2,7 @@
  * Monom class
  */
 import {Numeric} from "../numeric";
-import {Shutingyard, ShutingyardType, Token, tokenType} from "../shutingyard";
-import {log} from "util";
+import {Shutingyard, ShutingyardType, Token} from "../shutingyard";
 import {Fraction} from "../coefficients/fraction";
 
 export type literalType = {
@@ -273,7 +272,7 @@ export class Monom {
         if (L === '') {
             // No setLetter - means it's only a number !
             if (this._coefficient.value != 0) {
-                return `${this._coefficient.dfrac}`;
+                return `${this._coefficient.frac}`;
             } else {
                 return '0';
             }
@@ -285,7 +284,7 @@ export class Monom {
             } else if (this._coefficient.value === 0) {
                 return '0';
             } else {
-                return `${this._coefficient.dfrac}${L}`;
+                return `${this._coefficient.frac}${L}`;
             }
         }
     }

package/src/maths/algebra/polynom.ts

@@ -6,6 +6,7 @@ import {literalType, Monom} from './monom';
 import {Shutingyard, ShutingyardType, Token} from '../shutingyard';
 import {Numeric} from '../numeric';
 import {Fraction} from "../coefficients/fraction";
+import {Equation, ISolution} from "./equation";
 
 export type PolynomParsingType = string | Polynom | number | Fraction | Monom
 
@@ -65,6 +66,9 @@ export class Polynom {
     get texFactors(): string {
         this.factorize()
 
+        if (this.factors.length === 0) {
+            return this.tex
+        }
         let tex = ''
         for (let f of this.factors) {
             if (f.monoms.length > 1) {
@@ -209,8 +213,16 @@ export class Polynom {
 
         if (typeof inputStr === 'string') {
             return this._parseString(inputStr, ...values)
-        } else if (typeof inputStr === 'number' || inputStr instanceof Fraction || inputStr instanceof Monom) {
+        } else if (
+            (typeof inputStr === 'number' || inputStr instanceof Fraction || inputStr instanceof Monom)
+            && (values === undefined || values.length===0)
+        ) {
+            this._monoms.push(new Monom(inputStr))
+        } else if (inputStr instanceof Monom && values.length > 0) {
             this._monoms.push(new Monom(inputStr))
+            values.forEach(m => {
+                this._monoms.push(new Monom(m))
+            })
         } else if (inputStr instanceof Polynom) {
             for (const m of inputStr.monoms) {
                 this._monoms.push(m.clone())
@@ -773,6 +785,7 @@ export class Polynom {
         }
 
         let securityLoop = P.degree().clone().multiply(2).value
+        let result
         // securityLoop = 0
 
         while (securityLoop >= 0) {
@@ -780,110 +793,151 @@ export class Polynom {
 
             if (P.monoms.length < 2) {
                 if (!P.isOne()) {
-                    factors.push(P.clone());
+                    factors.push(P.clone())
+                    P.one()
                 }
-                break;
+                break
+            } else if (P.degree(letter).isOne()){
+                factors.push(P.clone())
+                P.one()
+                break
             } else {
-                // Get the first and last monom.
+                // Get the first and last monom and build all their dividers.
                 let m1 = P.monoms[0].dividers,
                     m2 = P.monoms[P.monoms.length - 1].dividers
 
-                for (let m1d of m1) {
-                    for (let m2d of m2) {
-                        // if(m1d.degree()===m2d.degree()){continue}
-                        let dividerPolynom = new Polynom(),
-                            result
-                        dividerPolynom.monoms = [m1d.clone(), m2d.clone()]
-                        result = P.euclidian(dividerPolynom)
-
-                        if (result.reminder.isZero()) {
-                            P = result.quotient.clone();
-                            factors.push(dividerPolynom)
-                            continue;
-                        }
+                // Create the list of all "potential" polynom dividers.
+                let allDividers:Polynom[] = this._getAllPotentialFactors(P,letter)
 
-                        dividerPolynom.monoms = [m1d.clone(), m2d.clone().opposed()]
-                        result = P.euclidian(dividerPolynom)
-                        if (result.reminder.isZero()) {
-                            P = result.quotient.clone();
-                            factors.push(dividerPolynom)
-                        }
+                allDividers.every(div => {
+                    result = P.euclidian(div)
+                    if(result.reminder.isZero()){
+                        P = result.quotient.clone()
+                        factors.push(div)
+                        return false
                     }
-                }
+                    return true
+                })
             }
         }
 
+        if (!P.isOne()) {
+            factors.push(P.clone())
+        }
+
         this.factors = factors
         return factors;
     }
 
-    // TODO: get zeroes for more than first degree and for more than natural degrees
-    getZeroes = (): (Fraction | boolean)[] => {
-        const Z: Fraction[] = [];
+    private _getAllPotentialFactors = (P: Polynom, letter?: string): Polynom[] => {
+        let m1 = P.monoms[0].dividers,
+            m2 = P.monoms[P.monoms.length - 1].dividers
 
-        switch (this.degree().value) {
-            case 0:
-                if (this._monoms[0].coefficient.value === 0) {
-                    return [true];
-                } else {
-                    return [false];
+        let allDividers: Polynom[] = []
+        m1.forEach(m1d => {
+            m2.forEach(m2d => {
+                if (m1d.degree(letter).isNotEqual(m2d.degree(letter))) {
+                    allDividers.push(new Polynom(m1d, m2d))
+                    allDividers.push(new Polynom(m1d, m2d.clone().opposed()))
                 }
-            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 = [];
-                for (let P of this._factors) {
-                    if (P.degree().greater(2)) {
-                        // TODO: Handle other polynom.
-
-                    } else if (P.degree().value === 2) {
-                        let A = P.monomByDegree(2).coefficient,
-                            B = P.monomByDegree(1).coefficient,
-                            C = P.monomByDegree(0).coefficient,
-                            D = B.clone().pow(2).subtract(A.clone().multiply(C).multiply(4));
-
-                        if (D.value > 0) {
-                            /*console.log('Two zeroes for ', P.tex); */
-                            let x1 = (-(B.value) + Math.sqrt(D.value)) / (2 * A.value),
-                                x2 = (-(B.value) - Math.sqrt(D.value)) / (2 * A.value);
+            })
+        })
 
-                            zeroes.push(new Fraction(x1.toFixed(3)).reduce());
-                            zeroes.push(new Fraction(x2.toFixed(3)).reduce());
-                        } else if (D.value === 0) {
-                            /*console.log('One zero for ', P.tex); */
+        return allDividers
 
-                        } else {
-                            console.log('No zero for ', P.tex);
-                        }
-                    } else {
-                        for (let z of P.getZeroes()) {
-                            // Check if the zero is already in the list.
-                            if (z === false || z === true) {
-                                continue;
-                            }
-                            if (zeroesAsTex.indexOf(z.frac) === -1) {
-                                zeroes.push(z);
-                                zeroesAsTex.push(z.frac);
-                            }
-                        }
-                    }
-                }
-                return zeroes;
-        }
-        return Z;
+    }
+    // TODO: get zeroes for more than first degree and for more than natural degrees
+    getZeroes = (): ISolution[] => {
+        let equ = new Equation(this.clone(), 0)
+        equ.solve()
+        return equ.solutions
+
+        //
+        // const Z: Fraction[] = [];
+        //
+        // // ISolution: {tex: string, value: number, exact: boolean|Fraction|...}
+        //
+        // switch (this.degree().value) {
+        //     case 0:
+        //         if (this._monoms[0].coefficient.value === 0) {
+        //             return [{
+        //                 tex: '\\mathbb{R}',
+        //                 value: NaN,
+        //                 exact: false
+        //             }];
+        //         } else {
+        //             return [{
+        //                 tex: '\\varnothing',
+        //                 value: NaN,
+        //                 exact: false
+        //             }];
+        //         }
+        //     case 1:
+        //         // There is only one monoms,
+        //         if (this._monoms.length === 1) {
+        //             return [{
+        //                 tex: '0',
+        //                 value: 0,
+        //                 exact: new Fraction().zero()
+        //             }];
+        //         } else {
+        //             const P = this.clone().reduce().reorder();
+        //             const coeff = P.monoms[1].coefficient.opposed().divide(P.monoms[0].coefficient)
+        //             return [{
+        //                 tex: coeff.tex,
+        //                 value: coeff.value,
+        //                 exact: coeff
+        //             }];
+        //         }
+        //     // TODO: Determine the zeros of an equation of second degree.
+        //     //case 2:
+        //     default:
+        //         // Make sure the polynom is factorized.
+        //         if (this._factors.length === 0) {
+        //             this.factorize()
+        //         }
+        //
+        //         let zeroes:Fraction[] = [], zeroesAsTex = [];
+        //         for (let P of this._factors) {
+        //             if (P.degree().greater(2)) {
+        //                 // TODO: get zeroes of polynom with a degree greater than 2.
+        //
+        //             } else if (P.degree().value === 2) {
+        //                 let A = P.monomByDegree(2).coefficient,
+        //                     B = P.monomByDegree(1).coefficient,
+        //                     C = P.monomByDegree(0).coefficient,
+        //                     D = B.clone().pow(2).subtract(A.clone().multiply(C).multiply(4));
+        //
+        //                 if (D.value > 0) {
+        //                     /*console.log('Two zeroes for ', P.tex); */
+        //                     let x1 = (-(B.value) + Math.sqrt(D.value)) / (2 * A.value),
+        //                         x2 = (-(B.value) - Math.sqrt(D.value)) / (2 * A.value);
+        //
+        //                     zeroes.push(new Fraction(x1.toFixed(3)).reduce());
+        //                     zeroes.push(new Fraction(x2.toFixed(3)).reduce());
+        //                 } else if (D.value === 0) {
+        //                     /*console.log('One zero for ', P.tex); */
+        //                 } else {
+        //                     console.log('No zero for ', P.tex);
+        //                 }
+        //             } else {
+        //                 for (let z of P.getZeroes()) {
+        //                     // Check if the zero is already in the list.
+        //                     // if (z === false || z === true) {
+        //                     //     continue;
+        //                     // }
+        //                     if (zeroesAsTex.indexOf(z.frac) === -1) {
+        //                         zeroes.push(z);
+        //                         zeroesAsTex.push(z.frac);
+        //                     }
+        //                 }
+        //             }
+        //         }
+        //
+        //
+        //         return zeroes;
+        // }
+        // return Z;
     };
 
     // TODO: analyse the next functions to determine if they are useful or not...
@@ -995,6 +1049,35 @@ export class Polynom {
         return M;
     }
 
+    limitToInfinity = (letter?: string): Fraction => {
+        const M = this.monomByDegree(undefined, letter),
+            sign = M.coefficient.sign(),
+            degree = M.degree(letter)
+
+        if (degree.isStrictlyPositive()) {
+            return sign === 1 ? (new Fraction()).infinite() : (new Fraction()).infinite().opposed()
+        } else if (degree.isZero()) {
+            return M.coefficient
+        }
+
+        // Any other cases
+        return (new Fraction()).zero()
+    }
+    limitToNegativeInfinity = (letter?: string): Fraction => {
+        const M = this.monomByDegree(undefined, letter),
+            sign = M.coefficient.sign(),
+            degree = M.degree(letter)
+
+        if (degree.isStrictlyPositive()) {
+            return sign === -1 ? (new Fraction()).infinite() : (new Fraction()).infinite().opposed()
+        } else if (degree.isZero()) {
+            return M.coefficient
+        }
+
+        // Any other cases
+        return (new Fraction()).zero()
+    }
+
     private _parseString(inputStr: string, ...values: unknown[]): Polynom {
         if (values === undefined || values.length === 0) {
             inputStr = '' + inputStr;