pimath 0.1.40 → 0.2.1

package/src/algebra/polynom.ts

@@ -9,7 +9,6 @@ import type {
     InputAlgebra,
     InputValue,
     IPiMathObject,
-    ISolution,
     literalType,
     TABLE_OF_SIGNS,
     TABLE_OF_SIGNS_VALUES
@@ -20,6 +19,7 @@ import {EquationSolver} from './equationSolver'
 import {Monom} from './monom'
 import {replace_in_array} from "../helpers"
 import {operation_pow} from "./operations"
+import {Solution} from "../analyze/solution"
 
 
 export type PolynomParsingType = InputValue<Polynom> | Monom
@@ -43,7 +43,7 @@ export class Polynom implements IPiMathObject<Polynom>,
     #defaultVariable = 'x'
     #factors: Polynom[]
     #monoms: Monom[]
-    #roots: ISolution[]
+    #roots: Solution[]
     #rootsCache = false
 
     constructor(value: InputValue<Fraction>)
@@ -63,6 +63,7 @@ export class Polynom implements IPiMathObject<Polynom>,
         return this
     }
 
+
     /**
      * Parse a string to a polynom.
      * @param inputStr
@@ -120,6 +121,16 @@ export class Polynom implements IPiMathObject<Polynom>,
         return this.#genDisplay()
     }
 
+    static xMultiply(...polynoms: InputValue<Polynom>[]): Polynom {
+        const result = new Polynom().one()
+
+        polynoms.forEach(P => {
+            result.multiply(P)
+        })
+
+        return result
+    }
+
     public add = (...values: InputAlgebra<Polynom>[]): Polynom => {
 
         for (const value of values) {
@@ -281,98 +292,62 @@ export class Polynom implements IPiMathObject<Polynom>,
     /**
      * Factorize a polynom and store the best results in factors.
      * @param letter
+     * TODO: Handle other letter than 'x'.
      */
+    public factorize(letter?: string): Polynom[] {
+        this.#factors = []
 
-        // REFACTOR: duplicate code with equationSolver.
-    public factorize = (letter?: string): Polynom[] => {
-        let factors: Polynom[] = []
         let P = this.clone().reorder()
 
         // Extract the common monom
         // 2x^3+6x^2 => 2x^2
         const M = P.commonMonom()
-        // If the polynom starts with a negative monom, factorize it.
-        if (P.monomByDegree().coefficient.isStrictlyNegative() && M.coefficient.isStrictlyPositive() && !M.isOne()) {
-            M.opposite()
-        }
 
+        // If the polynom starts with a negative monom, factorize it.
+        if (P.monomByDegree().coefficient.isStrictlyNegative()) M.opposite()
 
         if (!M.isOne()) {
-            const tempPolynom: Polynom = new Polynom(M)
-            factors = [tempPolynom.clone()]
-            P = P.euclidean(tempPolynom).quotient
+            this.#factors.push(new Polynom(M))
+            P = P.euclidean(this.#factors[0]).quotient
         }
 
-        // Main loop
-        let securityLoop = P.degree().clone().multiply(2).value,
-            maxDegree = 1
-        while (securityLoop >= 0) {
-            securityLoop--
-            if (P.monoms.length < 2) {
-                // The polynom has only one monom => 7x^2
-                // No need to continue.
-                if (!P.isOne()) {
-                    factors.push(P.clone())
-                    P.one()
-                }
-                break
-            } else if (P.degree(letter).isOne()) {
-                // The polynom is a first degree polynom => 3x-5
-                // No need to continue
-                factors.push(P.clone())
-                P.one()
-                break
-            } else {
-                // Create the list of all "potential" polynom dividers.
-                let allDividers: Polynom[] = this.#getAllPotentialFactors(P, maxDegree, letter ?? 'x')
-                maxDegree = P.degree(letter).value
-
-                // Actually: 100ms
-                while (allDividers.length > 0) {
-                    const div = allDividers[0]
-
-                    if (!P.isDividableBy(div))
-                        // Not dividable. Remove it from the list
-                    {
-                        allDividers.shift()
-                    } else {
-                        // It's dividable - so make the division
-                        const result = P.euclidean(div)
-
-                        // Add the factor
-                        factors.push(div)
-
-                        // As it's dividable, get the quotient.
-                        P = result.quotient.clone()
-
-                        // filter all dividers that are no more suitable.
-                        allDividers = allDividers.filter(x => {
-                            const pX = P.monoms[0],
-                                pC = P.monoms[P.monoms.length - 1],
-                                dX = x.monoms[0],
-                                dC = x.monoms[x.monoms.length - 1]
+        const solutions = new EquationSolver(P).solve()
 
-                            // Check last item (degree zero)
-                            if (!pC.isDivisible(dC)) {
-                                return false
-                            }
+        if (solutions.length === 0) {
+            this.#factors = [this.clone()]
+            return this.#factors
+        }
 
-                            // Check the first item (degree max)
-                            return pX.isDivisible(dX)
-                        })
+        solutions.forEach(sol => {
+            if (sol.exact && sol.root.isZero()) {
+                for (let i = 0; i < sol.count; i++) {
+                    if (sol.fraction.isRational()) {
+                        this.#factors.push(new Polynom().fromCoefficients(sol.fraction.denominator, -sol.fraction.numerator))
+                    } else {
+                        this.#factors.push(new Polynom().fromCoefficients(1, sol.fraction.clone().opposite()))
                     }
                 }
             }
-        }
+        })
 
-        // Maybe there is still something in the Polynom (not everything was possible to factorize)
-        if (!P.isOne()) {
-            factors.push(P.clone())
+        // Check if we have all factors.
+        const fDegrees = this.#factors
+            .map(f => f.degree().value)
+            .reduce((a, b) => a + b, 0)
+
+        if (fDegrees < this.degree().value) {
+            // missing polynom.
+            const fPolynom = Polynom.xMultiply(...this.#factors)
+            this.#factors.push(this.clone().divide(fPolynom))
         }
 
+        return this.#factors
+    }
 
-        // Save the factors
-        this.#factors = factors
+    get factors(): Polynom[] {
+        if (this.#factors.length === 0 && !this.isZero()) {
+            return this.factorize()
+        }
 
         return this.#factors
     }
@@ -435,7 +410,7 @@ export class Polynom implements IPiMathObject<Polynom>,
         return numerators
     }
 
-    public getZeroes = (): ISolution[] => {
+    public getZeroes = (): Solution[] => {
         if (this.degree().isZero()) {
             return []
         }
@@ -499,8 +474,8 @@ export class Polynom implements IPiMathObject<Polynom>,
         if (div.degree().isOne()) {
             const zero = div.getZeroes()[0]
 
-            if (zero.exact instanceof Fraction) {
-                return (this.evaluate(zero.exact) as Fraction).isZero()
+            if (zero.exact) {
+                return (this.evaluate(zero.fraction) as Fraction).isZero()
             } else {
                 return false
             }
@@ -528,30 +503,6 @@ export class Polynom implements IPiMathObject<Polynom>,
         return this.#compare(P.clone().opposite(), '=')
     }
 
-    public isReduced = (polynomString: string): boolean => {
-        // The polynom must be developed to be reduced.
-        if (!this.isDeveloped(polynomString)) {
-            return false
-        }
-
-
-        const P = new Polynom(polynomString)
-        if (P.monoms.length > this.monoms.length) {
-            return false
-        }
-
-
-        // TODO: Not sure the reduced system checking is working properly !
-        for (const m of P.monoms) {
-            if (!m.coefficient.isReduced()) {
-                return false
-            }
-        }
-
-
-        return false
-    }
-
     public isSameAs = (P: Polynom): boolean => {
         return this.#compare(P, 'same')
     }
@@ -684,26 +635,31 @@ export class Polynom implements IPiMathObject<Polynom>,
 
         if (value instanceof Polynom) {
             return this.#multiplyByPolynom(value)
-        } else if (value instanceof Fraction) {
+        }
+
+        if (value instanceof Fraction) {
             return this.#multiplyByFraction(value)
-        } else if (value instanceof Monom) {
+        }
+
+        if (value instanceof Monom) {
             return this.#multiplyByMonom(value)
-        } else if (Number.isSafeInteger(value) && typeof value === 'number') {
+        }
+
+        if (Number.isSafeInteger(value) && typeof value === 'number') {
             return this.#multiplyByInteger(value)
-        } else if (typeof value === 'string') {
+        }
+
+        if (typeof value === 'string') {
             try {
                 const k = new Fraction(value)
                 return this.#multiplyByFraction(k)
             } catch {
                 throw new Error('Cannot multiply by this value.')
             }
-
-
         }
 
-
         // Something went wrong...
-        throw new Error('Cannot multiply by this value.')
+        throw new Error(`Cannot multiply by this value: ${value as unknown as string}`)
     }
 
     public get numberOfVars(): number {
@@ -850,11 +806,11 @@ export class Polynom implements IPiMathObject<Polynom>,
         throw new Error('Cannot take the root from a polynom')
     }
 
-    get roots(): ISolution[] {
+    get roots(): Solution[] {
         return this.#rootsCache ? this.#roots : this.getZeroes()
     }
 
-    set roots(value: ISolution[]) {
+    set roots(value: Solution[]) {
         this.#rootsCache = true
         this.#roots = value
     }
@@ -888,7 +844,7 @@ export class Polynom implements IPiMathObject<Polynom>,
         // returns ['+-', 'd|t|z', '+-']...
 
         // global roots from eventually Polyfactor. Allows to add "extra column".
-        const roots: ISolution[] = this.roots
+        const roots: Solution[] = this.roots
 
         // Build the table os sign length and default values
         // The signs looks like: ['+', 't', '+', 't', '+', 't', '+']
@@ -962,7 +918,7 @@ export class Polynom implements IPiMathObject<Polynom>,
         return this
     }
 
-    public get zeroes(): ISolution[] {
+    public get zeroes(): Solution[] {
         return this.getZeroes()
     }
 
@@ -1025,110 +981,6 @@ export class Polynom implements IPiMathObject<Polynom>,
         return r
     }
 
-    #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().opposite().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()) {
-                    return [new Polynom(factor.display), P1, P2]
-                } else {
-                    return [P1, P2]
-                }
-
-            } else if (delta.isPositive() && delta.isSquare()) {
-                x1 = b.clone().opposite()
-                    .add(delta.clone().sqrt())
-                    .divide(a.clone().multiply(2))
-                x2 = b.clone().opposite()
-                    .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
-
-                    const xPolynom = new Polynom('x', a.coefficient, b.coefficient, c.coefficient)
-                    const xFactors = xPolynom.#factorize2ndDegree('x')
-
-                    const factors = []
-                    let xyzPolynom: Polynom
-
-                    if (xFactors.length >= 2) {
-                        for (const 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()]
-        }
-    }
-
     #genDisplay = (output?: string, forceSign?: boolean, wrapParentheses?: boolean, withAllMultiplicationSign?: boolean): string => {
         let P = ''
 
@@ -1391,4 +1243,5 @@ export class Polynom implements IPiMathObject<Polynom>,
 
     }
 
+
 }

package/src/analyze/index.ts

@@ -0,0 +1,4 @@
+// Exports every files from the algebra folder
+
+export * from "./solution"
+export * from "./tableOfSigns"

package/src/analyze/solution.ts

@@ -1,53 +1,86 @@
-// TODO: remplacer ISolution par Solution, qui sera plus robuste et extensible
-
 import type {InputValue} from "../pimath.interface"
 import {Fraction} from "../coefficients"
+import {Root} from "../coefficients/root"
 
 export class Solution {
-    #display: string
+    #count: number
+    #display: string | null
     #exact: boolean
-    #isZero: boolean
-    #tex: string
+    #fraction: Fraction
+    #root: Root
+    #tex: string | null
     #variable: string
 
     constructor() {
         this.#variable = 'x'
         this.#exact = false
-        this.#isZero = true
 
-        this.#display = '?'
-        this.#tex = '?'
+        this.#display = null
+        this.#tex = null
+
+        this.#fraction = new Fraction().zero()
+        this.#root = new Root()
+        this.#count = 1
     }
 
     get tex(): string {
-        return this.#tex
+        if (this.#tex) return this.#tex
+
+        if (this.#root.isZero()) return this.#fraction.tex
+
+        if (this.#fraction.isZero()) return this.#root.tex
+
+        const [f] = Fraction.toSameDenominateur(this.#fraction, this.#root.factor)
+
+        const R = this.#root.clone().multiply(f.denominator).reduce()
+        const num = `${f.numerator} ${R.withSign.tex}`
+
+        if (f.denominator === 1) return num
+
+        return `\\frac{ ${num} }{ ${f.denominator} }`
     }
 
-    set tex(value: string) {
+    set tex(value: string | null) {
         this.#tex = value
     }
 
-    get display(): string {
-        return this.#display
+    get display(): string | null {
+        if(this.#display) return this.#display
+
+        if (this.#root.isZero()) return this.#fraction.display
+
+        if (this.#fraction.isZero()) return this.#root.display
+
+        const [f] = Fraction.toSameDenominateur(this.#fraction, this.#root.factor)
+
+        const R = this.#root.clone().multiply(f.denominator).reduce()
+        const num = `${f.numerator}${R.withSign.display}`
+
+        if (f.denominator === 1) return num
+
+        return `(${num})/${f.denominator}`
     }
 
-    set display(value: string) {
+    set display(value: string | null) {
         this.#display = value
     }
 
     static fromFraction(value: InputValue<Fraction>): Solution {
         const sol = new Solution()
-        sol.isExact()
+        sol.setExact()
 
         const F = new Fraction(value)
         sol.display = F.display
         sol.tex = F.tex
 
+        sol.fraction = F
+        sol.root = new Root()
+
         return sol
     }
 
-    static fromQuadratic(values: [InputValue<Fraction>, InputValue<Fraction>, InputValue<Fraction>]): Solution[] {
-        const [a, b, c] = values.map(x => new Fraction(x))
+    static fromQuadratic(A: InputValue<Fraction>, B: InputValue<Fraction>, C: InputValue<Fraction>): Solution[] {
+        const [a, b, c] = [A, B, C].map(x => new Fraction(x))
 
         // D = b^2-4ac
         const delta2 = b.clone().pow(2).subtract(a.clone().multiply(c).multiply(4))
@@ -65,10 +98,25 @@ export class Solution {
                 : [Solution.fromFraction(root1), Solution.fromFraction(root2)]
         }
 
-        const solutions = [new Solution(), new Solution()]
-        solutions.forEach(sol=> sol.isExact(false))
+        const sol1 = new Solution()
+        sol1.fraction = b.clone().opposite().divide(a).divide(2)
+        sol1.root = new Root().from(2, delta2, a.clone().multiply(2).inverse().opposite())
+        sol1.setExact(false)
+
+        const sol2 = new Solution()
+        sol2.fraction = b.clone().opposite().divide(a).divide(2)
+        sol2.root = new Root().from(2, delta2, a.clone().multiply(2).inverse())
+        sol2.setExact(false)
 
-        return solutions
+        return [sol1, sol2]
+    }
+
+    get count(): number {
+        return this.#count
+    }
+
+    set count(value: number) {
+        this.#count = value
     }
 
     get exact(): boolean {
@@ -79,26 +127,41 @@ export class Solution {
         this.#exact = value
     }
 
-    isAZero(value = true): this {
-        this.#isZero = value
-        return this
+    get fraction(): Fraction {
+        return this.#fraction
     }
 
-    isExact(value = true): this {
-        this.#exact = value
+    set fraction(value: Fraction) {
+        this.#fraction = value
+    }
+
+    isZero(): boolean {
+        return this.#fraction.isZero() && this.#root.isZero()
+    }
+
+    reduce(): this {
+        // Reduce the root
+        this.#root.reduce()
+        this.#fraction.reduce()
+
         return this
     }
 
-    get isZero(): boolean {
-        return this.#isZero
+    get root(): Root {
+        return this.#root
     }
 
-    set isZero(value: boolean) {
-        this.#isZero = value
+    set root(value: Root) {
+        this.#root = value
+    }
+
+    setExact(value = true): this {
+        this.#exact = value
+        return this
     }
 
     get value(): number {
-        throw new Error("To be implemented")
+        return this.fraction.value + this.root.value
     }
 
     get variable(): string {

package/src/analyze/tableOfSigns.ts

@@ -1,5 +1,5 @@
 
-// TODO: move the TableOfSigns system to a custom class.
+// TODO: move the TableOfSigns asSystem to a custom class.
 
 import {Factor, PolyFactor, Polynom} from "../algebra"
 import type {InputAlgebra} from "../pimath.interface"