pimath 0.0.42 → 0.0.43

package/src/maths/algebra/equation.ts

@@ -2,28 +2,22 @@ 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...
  */
-export interface ISolution {
+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 = PARTICULAR_SOLUTION.varnothing;
-    private _real: string = PARTICULAR_SOLUTION.real;
+    private _varnothing: string = '\\varnothing';
+    private _real: string = '\\mathbb{R}';
 
     /**
      * Create an Equation using two polynoms.
@@ -165,9 +159,6 @@ export class Equation {
         return this.variables.length;
     }
 
-    hasVariable = (letter: string): boolean => {
-        return this.variables.includes(letter)
-    }
 
     // ------------------------------------------
     // Creation / parsing functions
@@ -406,29 +397,9 @@ 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))
     }
@@ -555,13 +526,12 @@ export class Equation {
                 }
             } else {
                 this._solutions = [{
-                    tex: v.tex,
+                    tex: v.display,
                     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()) {
@@ -595,7 +565,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,
@@ -624,7 +594,7 @@ export class Equation {
                     }
                 ]
             } else {
-                nthDelta = new NthRoot(delta).reduce();
+                nthDelta = new Nthroot(delta).reduce();
                 if (nthDelta.hasRadical()) {
                     // -b +- coeff\sqrt{radical}
                     // -------------------------
@@ -726,6 +696,7 @@ export class Equation {
             }];
         }
 
+
         // Handle now the inequations.
         if (!this.isStrictEqual()) {
             if (this._solutions.length === 2) {
@@ -792,29 +763,9 @@ export class Equation {
         return this._solutions;
     };
 
-    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 :(
+    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 :(
         return this._solutions;
     };
 }

package/src/maths/algebra/polynom.ts

@@ -6,7 +6,6 @@ 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
 
@@ -66,9 +65,6 @@ 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) {
@@ -777,7 +773,6 @@ export class Polynom {
         }
 
         let securityLoop = P.degree().clone().multiply(2).value
-        let result
         // securityLoop = 0
 
         while (securityLoop >= 0) {
@@ -796,8 +791,8 @@ export class Polynom {
                 for (let m1d of m1) {
                     for (let m2d of m2) {
                         // if(m1d.degree()===m2d.degree()){continue}
-                        let dividerPolynom = new Polynom()
-
+                        let dividerPolynom = new Polynom(),
+                            result
                         dividerPolynom.monoms = [m1d.clone(), m2d.clone()]
                         result = P.euclidian(dividerPolynom)
 
@@ -818,104 +813,77 @@ export class Polynom {
             }
         }
 
-        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 = (): 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;
+    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()
+                }
+
+                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); */
+
+                        } 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...
@@ -1027,34 +995,6 @@ 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;