pimath 0.1.40 → 0.2.1

package/src/algebra/equationSolver.ts

@@ -1,11 +1,12 @@
-import type {InputValue, ISolution} from "../pimath.interface"
+import type {InputValue} from "../pimath.interface"
 import type {Polynom} from "./polynom"
 import {Fraction} from "../coefficients"
 import {Numeric} from "../numeric"
 import type {Equation} from "./equation"
+import {Solution} from "../analyze"
 
 export class EquationSolver {
-    #bissectionCompexityCounter: number
+    _: number
     #bissectionDeltaX: number
     readonly #leftPolynom: Polynom
     readonly #variable: string
@@ -13,18 +14,21 @@ export class EquationSolver {
     constructor(left: Polynom | Equation, right?: Polynom, variable = "x") {
         this.#variable = variable
         this.#bissectionDeltaX = 1e-4
-        this.#bissectionCompexityCounter = 0
+        this._ = 0
 
+        // do this to avoid importing Polynom or Equation
         if (Object.hasOwn(left, 'moveLeft')) {
             const equ = left as Equation
             this.#leftPolynom = equ.left.clone().subtract(equ.right)
         } else {
             this.#leftPolynom = (left as Polynom).clone().subtract(right ?? 0)
         }
+
+        return this
     }
 
-    get bissectionCompexityCounter(){
-        return this.#bissectionCompexityCounter
+    get bissectionComplexityCounter() {
+        return this._
     }
 
     get bissectionDeltaX() {
@@ -35,7 +39,7 @@ export class EquationSolver {
         this.#bissectionDeltaX = value
     }
 
-    public solve(): ISolution[] {
+    public solve(): Solution[] {
         const degree = this.#leftPolynom.degree().value
 
         if (degree === 0) {
@@ -51,63 +55,58 @@ export class EquationSolver {
         }
 
         // Try to solve by factorization -> exact solutions.
-        const {solutions, polynom} = this.#solveByFactorization()
+        const {solutions, reminder} = this.#solveByFactorization()
 
         // The remaining polynom is of degree zero. No more solutions available.
-        if (polynom.degree().isZero()) {
+        if (reminder.degree().isZero()) {
             return solutions
         }
 
         // The remaining polyno is of degree one or two, but cannot be solved by factorization (!).
-        if (polynom.degree().value <= 2) {
+        if (reminder.degree().value <= 2) {
             return solutions.concat(
-                new EquationSolver(polynom.clone()).solve()
+                new EquationSolver(reminder.clone()).solve()
             )
         }
 
         // Use approximative solutions, using bissection algorithm.
-        // TODO: doit gérer le fait que si on a trouvé des solutions, on peut réduire avant de faire la bissection
-        this.#bissectionCompexityCounter = 0
+        this._ = 0
         return solutions.concat(
-            this.#solveByBissection(polynom)
+            this.#solveByBissection(reminder)
         ).sort((a, b) => a.value - b.value)
     }
 
-    public solveAsCardan(): ISolution[] {
+    public solveAsCardan(): Solution[] {
         if (this.#leftPolynom.degree().value !== 3) {
             throw new Error("The equation is not cubic.")
         }
         return this.#solveCubic_CardanFormula()
     }
 
-    #makeApproximativeSolution(value: number, output?: { tex: string, display: string }): ISolution {
-        return {
-            variable: this.#variable,
-            exact: false,
-            value: +value.toFixed(10),
-            tex: output?.tex ?? '',
-            display: output?.display ?? ''
-        }
+    #makeApproximativeSolution(value: number, output?: { tex: string, display: string }): Solution {
+        const sol = new Solution()
+
+        sol.exact = false
+        sol.tex = output?.tex ?? null
+        sol.display = output?.display ?? null
+        sol.fraction = new Fraction(value)
+        sol.fraction.exact = false
+        sol.variable = this.#variable
+
+        return sol
     }
 
-    #makeSolution(value: InputValue<Fraction>): ISolution {
-        if (value instanceof Fraction && value.isApproximative()) {
+    #makeSolution(value: InputValue<Fraction>): Solution {
+        if (value instanceof Fraction && !value.exact) {
             return this.#makeApproximativeSolution(value.value)
         }
 
-        const fraction = new Fraction(value)
-        return {
-            variable: this.#variable,
-            exact: fraction,
-            value: fraction.value,
-            tex: fraction.tex,
-            display: fraction.display
-        }
+        return Solution.fromFraction(value)
     }
 
     // Solve using bissection algorithm (approximative solution)
-    #solveByBissection(polynom: Polynom): ISolution[] {
-        const solutions: ISolution[] = []
+    #solveByBissection(polynom: Polynom): Solution[] {
+        const solutions: Solution[] = []
         const degree = polynom.degree().value
 
         // Calculate the Cauchy Bounds.
@@ -138,7 +137,6 @@ export class EquationSolver {
             }
         })
 
-        console.log('COMPLEXITY: ', this.#bissectionCompexityCounter)
         return solutions
     }
 
@@ -153,7 +151,7 @@ export class EquationSolver {
 
         let mid: number
         while ((b - a) / 2 > this.#bissectionDeltaX) {
-            this.#bissectionCompexityCounter++
+            this._++
 
             mid = (a + b) / 2
             const fmid = polynom.evaluate(mid, true) as number
@@ -216,14 +214,14 @@ export class EquationSolver {
         return couples
     }
 
-    #solveByFactorization(): { solutions: ISolution[], polynom: Polynom } {
+    #solveByFactorization(): { solutions: Solution[], reminder: Polynom } {
         // Move everything to the left.
 
         // Get the polynom on the left (on the right, it's zero)
         const left = this.#leftPolynom.clone()
 
         // The solutions of the equation
-        const solutions: ISolution[] = []
+        const solutions: Solution[] = []
 
         // multiply by the lcm of the denominators
         // to get rid of the fractions
@@ -275,24 +273,21 @@ export class EquationSolver {
         for (const s of solutions) {
             // all solutions are exact solutions.
             // skip the zero solutions if it exists.
-            if ((s.exact as Fraction).isZero()) {
+            if (s.isZero()) {
                 continue
             }
 
-            // // if the solution is exact and is zero, it's already divided: skip it !
-            // if (s.exact !== false && (s.exact as Fraction).isZero()) {
-            //     continue
-            // }
+            // The divider polynom
+            const p = left.clone()
+                .fromCoefficients(s.fraction.denominator, -s.fraction.numerator)
 
-            const p = left.clone().fromCoefficients(
-                (s.exact as Fraction).denominator,
-                -(s.exact as Fraction).numerator
-            )
-
-            // const p = this.#equation.clone().parse('x', (s.exact as Fraction).denominator, -(s.exact as Fraction).numerator)
+            // Reset the count
+            s.count = 0
 
+            // Divide as long it's dividable.
             while (left.isDividableBy(p)) {
                 left.divide(p)
+                s.count++
             }
         }
 
@@ -301,7 +296,7 @@ export class EquationSolver {
         if (left.degree().isZero() || left.degree().value > 3) {
             // Tri des réponses
             solutions.sort((a, b) => a.value - b.value)
-            return {solutions, polynom: left}
+            return {solutions, reminder: left}
         }
 
         // if the reduced polynom is of degree 1 or 2, we can solve it
@@ -312,11 +307,11 @@ export class EquationSolver {
             solutions: solutions
                 .concat(solver.solve())
                 .sort((a, b) => a.value - b.value),
-            polynom: zeroPolynom
+            reminder: zeroPolynom
         }
     }
 
-    #solveCubic_CardanFormula(): ISolution[] {
+    #solveCubic_CardanFormula(): Solution[] {
         // get the coefficients of the equation
         const left = this.#leftPolynom
 
@@ -353,10 +348,6 @@ export class EquationSolver {
         // delta = 0 : 2 real solutions
         // delta > 0 : 3 real solutions
         const delta = S.clone().pow(2).subtract(P.clone().multiply(4)).opposite()
-        // console.log('an=', an.display, 'bn=', bn.display, 'cn=', cn.display)
-        // console.log('p=', p.display, 'q=', q.display)
-        // console.log('S=', S.display, 'P=', P.display)
-        // console.log('delta=', delta.display)
 
         // if delta is negative, there is one real solution
         if (delta.isNegative()) {
@@ -406,7 +397,7 @@ export class EquationSolver {
         return []
     }
 
-    #solveLinear(): ISolution[] {
+    #solveLinear(): Solution[] {
         // The equation is linear.
         const [a, b] = this.#leftPolynom.getCoefficients()
 
@@ -418,7 +409,7 @@ export class EquationSolver {
         ]
     }
 
-    #solveQuadratic(): ISolution[] {
+    #solveQuadratic(): Solution[] {
 
         // The equation is quadratic.
         // We can solve it by isolating the variable.
@@ -453,7 +444,9 @@ export class EquationSolver {
 
             // Delta is zero, there is only one solution
             if (delta.isZero()) {
-                return [this.#makeSolution(f1)]
+                const sol = this.#makeSolution(f1)
+                sol.count = 2
+                return [sol]
             }
 
             // delta is positive, there are two solutions
@@ -472,68 +465,24 @@ export class EquationSolver {
         return this.#solveQuadratic_Output(a, b, delta2)
     }
 
-    #solveQuadratic_Output(a: Fraction, b: Fraction, delta: Fraction): ISolution[] {
+    #solveQuadratic_Output(a: Fraction, b: Fraction, delta: Fraction): Solution[] {
         // -b +/- sqrt(delta) / 2a
         // reduce the sqrt - extract pow.
-
-        // Get the greatest square factor
-        const deltaFactor: number = Numeric
-            .dividers(delta.value)
-            .filter(x => Math.sqrt(x) % 1 === 0)
-            .map(x => Math.sqrt(x)).pop() ?? 1
-
-        // Get the GCD of a, b, and the greatest delta factor.
-        const gcd = Numeric.gcd(2 * a.value, b.value, deltaFactor) * (a.isNegative() ? -1 : 1)
-
-        // Calculate the various values and transforming
-        const b2 = b.clone().divide(gcd).opposite()
-        const a2 = a.clone().divide(gcd).multiply(2)
-        const deltaGcd = Math.abs(deltaFactor / gcd)
-        const deltaTex = `${deltaFactor === 1 ? '' : deltaGcd + ' '}\\sqrt{ ${delta.clone().divide(deltaFactor ** 2).tex} }`
-        const deltaDisplay = `${deltaFactor === 1 ? '' : deltaGcd}sqrt(${delta.clone().divide(deltaFactor ** 2).display})`
-        // const deltaK1 = deltaFactor === 1 ? '-' : `-${deltaGcd} `
-        // const deltaK2 = deltaFactor === 1 ? '+' : `+${deltaGcd} `
-
-        function texOutput(a: string, b: string, sign: string, delta: string) {
-            // (B+D)/A
-            const B = b === '0' ? '' : b
-            const S = (sign === '-' || B !== '') ? ` ${sign} ` : ''
-
-            if (a === "1") {
-                return `${B}${S}${delta}`
-            }
-            return `\\frac{ ${S}${S}${delta} }{ ${a} }`
-        }
-
-        function displayOutput(a: string, b: string, sign: string, delta: string) {
-            // (B+D)/A
-            const B = b === '0' ? '' : b
-            const S = (sign === '-' || B !== '') ? sign : ''
-
-
-            if (a === "1") {
-                return `${B}${S}${delta}`
-            }
-            return `(${B}${S}${delta})/${a}`
-        }
-
-        const d = delta.value ** 0.5
-        const f1 = (-b.value - d) / (2 * a.value)
-        const f2 = (-b.value + d) / (2 * a.value)
-
-        return [
-            this.#makeApproximativeSolution(f1,
-                {
-                    tex: texOutput(a2.tex, b2.tex, '-', deltaTex),
-                    display: displayOutput(a2.display, b2.display, '-', deltaDisplay),
-                }
-            ),
-            this.#makeApproximativeSolution(f2,
-                {
-                    tex: texOutput(a2.tex, b2.tex, '+', deltaTex),
-                    display: displayOutput(a2.display, b2.display, '+', deltaDisplay),
-                }
-            )
-        ].sort((a, b) => a.value - b.value)
+        const a2 = a.clone().multiply(2)
+
+        const sol1 = new Solution()
+        sol1.fraction = b.clone().opposite().divide(a2.clone())
+        sol1.root.radical = delta.clone()
+        sol1.root.factor = new Fraction().one().divide(a2.clone())
+        sol1.exact = true
+
+        const sol2 = new Solution()
+        sol2.fraction = b.clone().opposite().divide(a2.clone())
+        sol2.root.radical = delta.clone()
+        sol2.root.factor = new Fraction().one().divide(a2.clone()).opposite()
+        sol2.exact = true
+
+        return [sol1, sol2]
+            .sort((a, b) => a.value - b.value)
     }
 }

package/src/algebra/factor.ts

@@ -4,7 +4,6 @@ import type {
     InputAlgebra,
     InputValue,
     IPiMathObject,
-    ISolution,
     literalType,
     TABLE_OF_SIGNS
 } from "../pimath.interface"
@@ -22,7 +21,6 @@ export class Factor implements IPiMathObject<Factor>,
 
     constructor(value?: InputAlgebra<Polynom> | Factor, power?: InputValue<Fraction>) {
 
-
         if (value instanceof Factor) {
             this.#polynom = value.polynom.clone()
             this.#power = value.power.clone()
@@ -51,11 +49,6 @@ export class Factor implements IPiMathObject<Factor>,
         return new Factor(this)
     }
 
-    public fromPolynom(polynom: InputValue<Polynom>): this {
-        this.#polynom = new Polynom(polynom)
-        this.#power = new Fraction(1)
-        return this
-    }
     public get tex(): string {
         const num = this.power.numerator
         const den = this.power.denominator
@@ -178,6 +171,12 @@ export class Factor implements IPiMathObject<Factor>,
         return (this.polynom.evaluate(values) as Fraction).pow(this.power)
     }
 
+    public fromPolynom(polynom: InputValue<Polynom>): this {
+        this.#polynom = new Polynom(polynom)
+        this.#power = new Fraction(1)
+        return this
+    }
+
     public hasVariable(letter: string): boolean {
         return this.polynom.hasVariable(letter)
     }

package/src/algebra/linearSystem.ts

@@ -1,16 +1,19 @@
-import type {IAlgebra, IEquation, InputValue, IPiMathObject, ISolution, literalType} from "../pimath.interface"
+import type {IAlgebra, IEquation, InputValue, IPiMathObject, literalType} from "../pimath.interface"
 import {Fraction} from "../coefficients"
 import {Equation} from "./equation"
 import {Monom} from "./monom"
 import {Polynom} from "./polynom"
+import {Numeric} from "../numeric"
+import type {Solution} from "../analyze/solution"
 
 export class LinearSystem implements IPiMathObject<LinearSystem>,
     IEquation<LinearSystem>,
     IAlgebra<LinearSystem> {
 
     #equations: Equation[]
-
-    // Determine the letters in the linear system, usually ['x', 'y']
+    // Solve steps for TeX output.
+    #steps: string[] = []
+    // Determine the letters in the linear asSystem, usually ['x', 'y']
     #variables: string[]
 
     constructor(...values: (string | Equation)[]) {
@@ -38,6 +41,21 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
             .parse(...this.#equations.map(equ => equ.clone()))
     }
 
+    public get tex(): string {
+        // Build the array of values.
+        // Reorder
+        // This clone the asSystem :!!!
+        //TODO: Avoid cloning this linear asSystem
+        const LS = this.clone().reorder()
+
+        return this.buildTex(LS.equations)
+    }
+
+    get display() {
+        // TODO : LinearSystem - display: implement the display of the linear asSystem
+        return this.tex + 'as display'
+    }
+
     public static fromMatrix(
         matrix: InputValue<Fraction>[][],
         letters = 'xyz'): LinearSystem {
@@ -88,7 +106,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         let letters: string[] = []
         const equArray: string[] = []
 
-        // Get the letters from the linear system
+        // Get the letters from the linear asSystem
         for (const equ of equations) {
             letters = letters.concat(equ.letters())
         }
@@ -141,11 +159,6 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         return Fraction.max(...this.#equations.map(equ => equ.degree(letter)))
     }
 
-    get display() {
-        // TODO : LinearSystem - display: implement the display of the linear system
-        return this.tex + 'as display'
-    }
-
     // ------------------------------------------
     public get equations(): Equation[] {
         return this.#equations
@@ -153,6 +166,9 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
 
     public set equations(value) {
         this.#equations = value
+
+        // update the variables.
+        this.#findLetters()
     }
 
     public evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean): number | Fraction {
@@ -185,21 +201,20 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         return this.#makeMatrix()
     }
 
-    public mergeEquations = (eq1: Equation, eq2: Equation, factor1: Fraction, factor2: Fraction): Equation => {
+    public mergeEquations(equation1: { id: number, factor: InputValue<Fraction> }, equation2: {
+        id: number,
+        factor: number
+    }): Equation {
         // Set and clone the equations.
-
-        const eq1multiplied = eq1.clone().multiply(new Fraction(factor1)),
-            eq2multiplied = eq2.clone().multiply(new Fraction(factor2))
+        const eq1multiplied = this.equations[equation1.id].clone().multiply(equation1.factor)
+        const eq2multiplied = this.equations[equation2.id].clone().multiply(equation2.factor)
 
         // Add both equations together.
-        eq1multiplied.left.add(eq2multiplied.left)
-        eq1multiplied.right.add(eq2multiplied.right)
-
-        return eq1multiplied
+        return eq1multiplied.add(eq2multiplied)
     }
 
     public multiply(value: InputValue<Fraction> | InputValue<Fraction>[], index?: number): this {
-        // Multiply the system by a number
+        // Multiply the asSystem by a number
         // the value can be an array of numbers
         // the value can be a number and the index of the equation to multiply
         if (Array.isArray(value)) {
@@ -222,8 +237,10 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         return this
     }
 
-    public reduce(): LinearSystem {
-        throw new Error("Method not implemented.")
+    public reduce(): this {
+        // reduce all equations at once.
+        this.equations.forEach(equ=>equ.reduce())
+        return this
     }
 
     // ------------------------------------------
@@ -235,7 +252,34 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         return this
     }
 
-    solve(): ISolution[] {
+    solve(): Solution[] {
+        // TODO : à retravailler, car ce n'est ni l'endroit, ni l'intérêt de l'avoir ici.
+        // 1. search in the equations if a variable has two same or opposite value = candidate for merging
+        // 2. if 1 is false, search for a variable that has coefficient one
+        // 3. if 2 is false, search for a variable that has a coefficient multiple of another.
+        // 4. if 3 is false, multiply both lines.
+        // => merge the equations and cycle.
+        const output: string[] = [this.tex]
+
+        const LS = this.clone()
+
+        while (LS.variables.length>1){
+            const letter = LS.variables[LS.variables.length-1]
+            const emptyLS = new LinearSystem()
+            const factors = LS.solve_compute_factors(letter).slice(0, LS.variables.length-1)
+            factors.forEach(factor=> {
+                emptyLS.equations.push(LS.mergeEquations(...factor))
+            })
+
+            LS.equations = emptyLS.equations
+
+            output.push(LS.tex)
+
+            // add the same but with a reduced value.
+            LS.reduce()
+            output.push(LS.tex)
+        }
+
         return []
     }
 
@@ -243,9 +287,6 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         const [matrix, vector] = this.matrix
         // Solve the matrix
 
-        // console.log(matrix.map(row=>row.map(x=>x.display)))
-        // console.log(vector.map(x=>x.display))
-
         // Make the augmented matrix (matrix + vector)
         const augmentedMatrix: Fraction[][] = matrix.map((row, index) => [...row, vector[index]])
 
@@ -286,10 +327,10 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
                     augmentedMatrix[j][k].add(augmentedMatrix[i][k].clone().multiply(factor))
                 }
 
-                // Check if the system is undetermined (no solution or infinite solutions)
+                // Check if the asSystem is undetermined (no solution or infinite solutions)
                 // the j line must not be all zeros
-                // the last element must be zero => the system is undetermined
-                // the last element must not be zero => the system is impossible
+                // the last element must be zero => the asSystem is undetermined
+                // the last element must not be zero => the asSystem is impossible
                 if (augmentedMatrix[j].slice(0, augmentedMatrix[j].length - 1).every(x => x.isZero())) {
                     if (augmentedMatrix[j][augmentedMatrix[j].length - 1].isZero()) {
                         return [new Fraction().infinite()]
@@ -303,6 +344,34 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         return augmentedMatrix.map(x => x[x.length - 1])
     }
 
+    solve_compute_factors(letter: string):
+        [{ id: number, factor: number }, { id: number, factor: number }][] {
+        // when solving, every monoms with a variable is on the left !
+        // and every coefficient are relative numbers.
+        const result: [{ id: number, factor: number }, { id: number, factor: number }][] = []
+        const coefficients = this.equations.map(equ => equ.left.monomByLetter(letter).coefficient.value)
+
+        // search for a factor
+        coefficients.forEach((reference, index) => {
+            for (let i = index + 1; i < coefficients.length; i++) {
+                const lcm = Numeric.lcm(reference, coefficients[i])
+
+                const sign = reference < 0 ? -1 : 1
+                result.push([
+                    {
+                        id: index, factor: sign * lcm / reference
+                    }, {
+                        id: i, factor: -sign * lcm / coefficients[i]
+                    }])
+            }
+        })
+
+        // Sort the value: prefer the smallest absolute values (1/-1, 2/-2, ...)
+        return result.sort((a, b) => {
+            return (Math.abs(a[0].factor) + Math.abs(a[1].factor)) - (Math.abs(b[0].factor) + Math.abs(b[1].factor))
+        })
+    }
+
     public subtract(value: InputValue<LinearSystem | Equation | Polynom>, index?: number): this {
         if (value instanceof LinearSystem) {
             const length = value.equations.length
@@ -324,16 +393,6 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         return this
     }
 
-    public get tex(): string {
-        // Build the array of values.
-        // Reorder
-        // This clone the system :!!!
-        //TODO: Avoid cloning this linear system
-        const LS = this.clone().reorder()
-
-        return this.buildTex(LS.equations)
-    }
-
     public get variables(): string[] {
         return this.#variables
     }
@@ -348,15 +407,7 @@ export class LinearSystem implements IPiMathObject<LinearSystem>,
         this.#variables = this.#equations.reduce((acc: string[], equ) => {
             return [...new Set([...acc, ...equ.variables])]
         }, [])
-        //
-        // // Find all letters used.
-        // let variables = new Set<string>()
-        //
-        // for (const equ of this.#equations) {
-        //     variables = new Set([...variables, ...equ.variables])
-        // }
-        //
-        // this.#variables = [...variables]
+
         this.#variables.sort()
         return this
     }