pimath 0.2.13 → 0.2.15

package/src/algebra/factor.ts

@@ -1,392 +1,396 @@
-import type {
-    IAlgebra,
-    IExpression,
-    InputAlgebra,
-    InputValue,
-    IPiMathObject,
-    literalType,
-    TABLE_OF_SIGNS
-} from "../pimath.interface"
-import {Fraction} from "../coefficients/fraction"
-import {Polynom} from "./polynom"
-import {replace_in_array, splitIfOutsideParentheses, wrapParenthesis} from "../helpers"
-import {MathError, NotImplementedError} from "../errors"
-
-export class Factor implements IPiMathObject<Factor>,
-    IExpression<Factor>,
-    IAlgebra<Factor> {
-    #displayMode: FACTOR_DISPLAY
-    #polynom: Polynom
-    #power: Fraction
-    #singleMode = false
-
-    constructor(value?: InputAlgebra<Polynom> | Factor, power?: InputValue<Fraction>) {
-
-        if (value instanceof Factor) {
-            this.#polynom = value.polynom.clone()
-            this.#power = value.power.clone()
-
-            if (power !== undefined) {
-                this.#power.multiply(new Fraction(power))
-            }
-        } else if (value !== undefined) {
-            this.#polynom = new Polynom(value)
-            this.#power = new Fraction(power ?? 1)
-        } else {
-            this.#polynom = new Polynom()
-            this.#power = new Fraction(1)
-        }
-
-        this.#displayMode = FACTOR_DISPLAY.POWER
-
-        return this
-    }
-
-    public parse(/*value: InputValue<Factor>*/): Factor {
-        throw new NotImplementedError("Method not implemented.")
-    }
-
-    public clone(): Factor {
-        return new Factor(this)
-    }
-
-    public get tex(): string {
-        const num = this.power.numerator
-        const den = this.power.denominator
-
-        let base: string
-        let power: string
-
-        if (this.#displayMode === FACTOR_DISPLAY.ROOT && den > 1) {
-            base = `\\sqrt${den === 2 ? '' : `[ ${den} ]`}{ ${this.polynom.tex} }`
-            power = num === 1 ? '' : `^{ ${num} }`
-        } else {
-            base = this.#singleMode && this.power.isOne() ? this.polynom.tex : wrapParenthesis(this.polynom.tex)
-            power = (den === 1 && num === 1) ? '' : `^{ ${this.power.tex} }`
-        }
-
-        // Add the power if it's not 1 or -1
-        base = `${base}${power}`
-
-        // If the power is negative, make it as a fraction.
-        if (this.#displayMode === FACTOR_DISPLAY.ROOT && num < 0) {
-            base = `\\frac{ 1 }{ ${base} }`
-        }
-
-
-        return base
-    }
-
-    public get display(): string {
-        const num = this.power.numerator
-        const den = this.power.denominator
-
-        let base: string
-        let power: string
-
-        if (this.#displayMode === FACTOR_DISPLAY.ROOT && den > 1) {
-            base = `${den === 2 ? 'sqrt' : `root(${den})`}(${this.polynom.display})`
-            power = num === 1 ? '' : `^(${num})`
-        } else {
-            base = this.#singleMode && this.power.isOne() ? this.polynom.display : wrapParenthesis(this.polynom.display, false)
-            power = (den === 1 && num === 1) ? '' : `^(${this.power.display})`
-        }
-
-        // Add the power if it's not 1 or -1
-        base = `${base}${power}`
-
-        // If the power is negative, make it as a fraction.
-        if (this.#displayMode === FACTOR_DISPLAY.ROOT && num < 0) {
-            base = `1/(${base})`
-        }
-
-
-        return base
-    }
-
-    public add(): Factor {
-        throw new MathError("Adding two factors is not possible")
-    }
-
-    public get asSingle(): this {
-        this.#singleMode = true
-        return this
-    }
-
-    public degree(letter?: string): Fraction {
-        return this.polynom.degree(letter).multiply(this.power)
-    }
-
-    public derivative(): Factor[] {
-        // The power is zero, the derivative is zero
-        if (this.power.isZero()) {
-            return [new Factor('0')]
-        }
-
-        // The power is one, the derivative is the derivative of the polynom
-        if (this.power.isOne()) {
-            return [new Factor(this.polynom.clone().derivative())]
-        }
-
-        // In any other case, the derivative consist of three Factors:
-        // the derivative of the polynom, the power and the polynom
-        return [
-            new Factor(this.power.clone()),
-            new Factor(this.polynom.clone().derivative()),
-            new Factor(this.polynom.clone(), this.power.clone().subtract(1))
-        ]
-    }
-
-    public develop(): Polynom {
-        if (this.power.isNatural()) {
-            return this.polynom.clone().pow(this.power.value)
-        }
-
-        throw new MathError("The power must be a natural number")
-    }
-
-    public divide(value: InputAlgebra<Factor | Polynom>): this {
-        if (value instanceof Factor) {
-            if (this.isSameAs(value)) {
-                this.power.subtract(value.power)
-                return this
-            }
-        }
-
-
-        const P = new Polynom(value as Polynom)
-        if (this.isSameAs(P)) {
-            this.power.subtract(1)
-            return this
-        }
-
-        throw new MathError("The two factors must be the same")
-    }
-
-    public evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean): number | Fraction {
-        if (asNumeric) {
-            return (this.polynom.evaluate(values, true) as number) ** this.power.value
-        }
-
-
-        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)
-    }
-
-    public inverse(): this {
-        this.power.opposite()
-        return this
-    }
-
-    public isEqual(value: Factor): boolean {
-        // Must have the same polynom and the same reduce power
-
-        return this.isSameAs(value) &&
-            this.power.isEqual(value.power)
-    }
-
-    public isOne(): boolean {
-        return this.polynom.isOne() || this.power.isZero()
-    }
-
-    public isSameAs(value: InputAlgebra<Factor | Polynom>) {
-        let P: Polynom
-        if (value instanceof Factor) {
-            P = value.polynom
-        } else if (value instanceof Polynom) {
-            P = value
-        } else {
-            P = new Polynom(value)
-        }
-
-
-        return this.polynom.isEqual(P)
-    }
-
-    public isZero(): boolean {
-        return this.polynom.isZero()
-    }
-
-    public multiply(value: InputAlgebra<Factor | Polynom>): this {
-        const F = new Factor(value)
-
-        // Case if this and value are monoms of degree one.
-        if(this.polynom.monoms.length===1 && this.power.isOne()
-            &&
-            F.polynom.monoms.length===1 && this.power.isOne()
-        ){
-            this.polynom.multiply(F.polynom)
-            return this
-        }
-
-        if (value instanceof Factor) {
-            if (this.isSameAs(value)) {
-                this.power.add(value.power)
-                return this
-            }
-        }
-
-
-        const P = new Polynom(value as Polynom)
-        if (this.isSameAs(P)) {
-            this.power.add(1)
-            return this
-        }
-
-        throw new MathError("The two factors must be the same")
-    }
-
-    public one(): this {
-        this.#polynom.one()
-        this.#power.one()
-        return this
-    }
-
-    public opposite(): Factor {
-        throw new NotImplementedError("Method not implemented.")
-    }
-
-    public get polynom(): Polynom {
-        return this.#polynom
-    }
-
-    public set polynom(value: Polynom) {
-        this.#polynom = value
-    }
-
-    public pow(value: number | Fraction): this {
-        this.power.multiply(value)
-        return this
-    }
-
-    public get power(): Fraction {
-        return this.#power
-    }
-
-    public set power(value: InputValue<Fraction>) {
-        this.#power = new Fraction(value)
-    }
-
-    public primitive(): Factor {
-        throw new NotImplementedError("Method not implemented.")
-    }
-
-    public reduce(): Factor {
-        throw new NotImplementedError("Method not implemented.")
-    }
-
-    public root(value: number): this {
-        this.power.divide(value)
-        return this
-    }
-
-    public sqrt(): this {
-        return this.root(2)
-    }
-
-    public subtract(): Factor {
-        throw new MathError("Subtracting two factors is not possible")
-    }
-
-    public tableOfSigns(): TABLE_OF_SIGNS {
-        const pow = this.power.clone().reduce()
-        const tos = this.polynom.tableOfSigns()
-
-        // The zero roots becomes defence (d) if the power is negative
-        if (pow.isStrictlyNegative()) {
-            tos.signs = replace_in_array(tos.signs, 'z', 'd')
-        }
-
-        // The - sign becomes
-        // + (plus) if the power num is even and the power den is odd
-        // i (invalid) if the power denominator is even
-        if (pow.denominator % 2 === 0) {
-            // it's an even roots : no negative values!
-            tos.signs = replace_in_array(tos.signs, '-', 'h')
-        } else if (pow.numerator % 2 === 0) {
-            // it's an even power :  negative values becomes positive !
-            tos.signs = replace_in_array(tos.signs, '-', '+')
-        }
-
-
-        return {roots: tos.roots, signs: tos.signs}
-    }
-
-    public get variables(): string[] {
-        return this.polynom.variables
-    }
-
-    public get withPower(): this {
-        this.#displayMode = FACTOR_DISPLAY.POWER
-        return this
-    }
-
-    public get withRoot(): this {
-        this.#displayMode = FACTOR_DISPLAY.ROOT
-        return this
-    }
-
-    public zero(): this {
-        this.#polynom.zero()
-        this.#power.one()
-        return this
-    }
-
-    static checkParseAsFactors(str: string): boolean {
-        const splitPlus = splitIfOutsideParentheses(str, "+")
-        if(splitPlus[0]==='') splitPlus.shift()
-        if(splitPlus.length>1) return false
-
-        const splitMinus = splitIfOutsideParentheses(str, "-")
-        if(splitMinus[0]==='') splitMinus.shift()
-        if(splitMinus.length>1) return false
-
-        return true
-    }
-
-    static factorsFromString(value: string, isNumerator = true): Factor[] {
-        if (!Factor.checkParseAsFactors(value)) {
-            return [new Factor(value, isNumerator ? 1 : -1)]
-        }
-
-        const sign = isNumerator ? 1 : -1
-        const factors: Factor[] = []
-
-        // Alternance : facteur parenthésé avec puissance optionnelle | séquence non-parenthésée
-        const regex =
-            /\(([^)]+)\)(?:\^(-?[0-9]+(?:\/[0-9]+)?|\(-?[0-9]+(?:\/[0-9]+)?\)))?|([^(]+)/g
-
-        for (const match of value.matchAll(regex)) {
-            if (match[1] !== undefined) {
-                // Cas : (expr)^puissance
-                const powStr = (match[2] ?? '1')
-                    .replace(/[()]/g, '')
-
-                factors.push(new Factor(
-                    new Polynom(match[1]),
-                    new Fraction(powStr).multiply(sign))
-                )
-            } else if (match[3]?.trim()) {
-                // Cas : monôme ou constante hors parenthèses (ex: 3x^2, 3)
-                factors.push(new Factor(new Polynom(match[3].trim()), new Fraction(sign)))
-            }
-        }
-
-        return factors
-    }
-}
-
-export enum FACTOR_DISPLAY {
-    ROOT,
-    POWER
-}
-
+import type {
+    IAlgebra,
+    IExpression,
+    InputAlgebra,
+    InputValue,
+    IPiMathObject,
+    literalType,
+    TABLE_OF_SIGNS
+} from "../pimath.interface"
+import {Fraction} from "../coefficients/fraction"
+import {Polynom} from "./polynom"
+import {replace_in_array, splitIfOutsideParentheses, wrapParenthesis} from "../helpers"
+import {MathError, NotImplementedError} from "../errors"
+
+export class Factor implements IPiMathObject<Factor>,
+    IExpression<Factor>,
+    IAlgebra<Factor> {
+    #displayMode: FACTOR_DISPLAY
+    #polynom: Polynom
+    #power: Fraction
+    #singleMode = false
+
+    constructor(value?: InputAlgebra<Polynom> | Factor, power?: InputValue<Fraction>) {
+
+        if (value instanceof Factor) {
+            this.#polynom = value.polynom.clone()
+            this.#power = value.power.clone()
+
+            if (power !== undefined) {
+                this.#power.multiply(new Fraction(power))
+            }
+        } else if (value !== undefined) {
+            this.#polynom = new Polynom(value)
+            this.#power = new Fraction(power ?? 1)
+        } else {
+            this.#polynom = new Polynom()
+            this.#power = new Fraction(1)
+        }
+
+        this.#displayMode = FACTOR_DISPLAY.POWER
+
+        return this
+    }
+
+    parse(/*value: InputValue<Factor>*/): Factor {
+        throw new NotImplementedError("Method not implemented.")
+    }
+
+    copy(): this {
+        throw new NotImplementedError("copy() is not yet implemented for Factor")
+    }
+
+    clone(): Factor {
+        return new Factor(this)
+    }
+
+    get tex(): string {
+        const num = this.power.numerator
+        const den = this.power.denominator
+
+        let base: string
+        let power: string
+
+        if (this.#displayMode === FACTOR_DISPLAY.ROOT && den > 1) {
+            base = `\\sqrt${den === 2 ? '' : `[ ${den} ]`}{ ${this.polynom.tex} }`
+            power = num === 1 ? '' : `^{ ${num} }`
+        } else {
+            base = this.#singleMode && this.power.isOne() ? this.polynom.tex : wrapParenthesis(this.polynom.tex)
+            power = (den === 1 && num === 1) ? '' : `^{ ${this.power.tex} }`
+        }
+
+        // Add the power if it's not 1 or -1
+        base = `${base}${power}`
+
+        // If the power is negative, make it as a fraction.
+        if (this.#displayMode === FACTOR_DISPLAY.ROOT && num < 0) {
+            base = `\\frac{ 1 }{ ${base} }`
+        }
+
+
+        return base
+    }
+
+    get display(): string {
+        const num = this.power.numerator
+        const den = this.power.denominator
+
+        let base: string
+        let power: string
+
+        if (this.#displayMode === FACTOR_DISPLAY.ROOT && den > 1) {
+            base = `${den === 2 ? 'sqrt' : `root(${den})`}(${this.polynom.display})`
+            power = num === 1 ? '' : `^(${num})`
+        } else {
+            base = this.#singleMode && this.power.isOne() ? this.polynom.display : wrapParenthesis(this.polynom.display, false)
+            power = (den === 1 && num === 1) ? '' : `^(${this.power.display})`
+        }
+
+        // Add the power if it's not 1 or -1
+        base = `${base}${power}`
+
+        // If the power is negative, make it as a fraction.
+        if (this.#displayMode === FACTOR_DISPLAY.ROOT && num < 0) {
+            base = `1/(${base})`
+        }
+
+
+        return base
+    }
+
+    add(): Factor {
+        throw new MathError("Adding two factors is not possible")
+    }
+
+    get asSingle(): this {
+        this.#singleMode = true
+        return this
+    }
+
+    degree(letter?: string): Fraction {
+        return this.polynom.degree(letter).multiply(this.power)
+    }
+
+    derivative(): Factor[] {
+        // The power is zero, the derivative is zero
+        if (this.power.isZero()) {
+            return [new Factor('0')]
+        }
+
+        // The power is one, the derivative is the derivative of the polynom
+        if (this.power.isOne()) {
+            return [new Factor(this.polynom.clone().derivative())]
+        }
+
+        // In any other case, the derivative consist of three Factors:
+        // the derivative of the polynom, the power and the polynom
+        return [
+            new Factor(this.power.clone()),
+            new Factor(this.polynom.clone().derivative()),
+            new Factor(this.polynom.clone(), this.power.clone().subtract(1))
+        ]
+    }
+
+    develop(): Polynom {
+        if (this.power.isNatural()) {
+            return this.polynom.clone().pow(this.power.value)
+        }
+
+        throw new MathError("The power must be a natural number")
+    }
+
+    divide(value: InputAlgebra<Factor | Polynom>): this {
+        if (value instanceof Factor) {
+            if (this.isSameAs(value)) {
+                this.power.subtract(value.power)
+                return this
+            }
+        }
+
+
+        const P = new Polynom(value as Polynom)
+        if (this.isSameAs(P)) {
+            this.power.subtract(1)
+            return this
+        }
+
+        throw new MathError("The two factors must be the same")
+    }
+
+    evaluate(values: InputValue<Fraction> | literalType<number | Fraction>, asNumeric?: boolean): number | Fraction {
+        if (asNumeric) {
+            return (this.polynom.evaluate(values, true) as number) ** this.power.value
+        }
+
+
+        return (this.polynom.evaluate(values) as Fraction).pow(this.power)
+    }
+
+    fromPolynom(polynom: InputValue<Polynom>): this {
+        this.#polynom = new Polynom(polynom)
+        this.#power = new Fraction(1)
+        return this
+    }
+
+    hasVariable(letter: string): boolean {
+        return this.polynom.hasVariable(letter)
+    }
+
+    inverse(): this {
+        this.power.opposite()
+        return this
+    }
+
+    isEqual(value: Factor): boolean {
+        // Must have the same polynom and the same reduce power
+
+        return this.isSameAs(value) &&
+            this.power.isEqual(value.power)
+    }
+
+    isOne(): boolean {
+        return this.polynom.isOne() || this.power.isZero()
+    }
+
+    isSameAs(value: InputAlgebra<Factor | Polynom>) {
+        let P: Polynom
+        if (value instanceof Factor) {
+            P = value.polynom
+        } else if (value instanceof Polynom) {
+            P = value
+        } else {
+            P = new Polynom(value)
+        }
+
+
+        return this.polynom.isEqual(P)
+    }
+
+    isZero(): boolean {
+        return this.polynom.isZero()
+    }
+
+    multiply(value: InputAlgebra<Factor | Polynom>): this {
+        const F = new Factor(value)
+
+        // Case if this and value are monoms of degree one.
+        if(this.polynom.monoms.length===1 && this.power.isOne()
+            &&
+            F.polynom.monoms.length===1 && this.power.isOne()
+        ){
+            this.polynom.multiply(F.polynom)
+            return this
+        }
+
+        if (value instanceof Factor) {
+            if (this.isSameAs(value)) {
+                this.power.add(value.power)
+                return this
+            }
+        }
+
+
+        const P = new Polynom(value as Polynom)
+        if (this.isSameAs(P)) {
+            this.power.add(1)
+            return this
+        }
+
+        throw new MathError("The two factors must be the same")
+    }
+
+    one(): this {
+        this.#polynom.one()
+        this.#power.one()
+        return this
+    }
+
+    opposite(): Factor {
+        throw new NotImplementedError("Method not implemented.")
+    }
+
+    get polynom(): Polynom {
+        return this.#polynom
+    }
+
+    set polynom(value: Polynom) {
+        this.#polynom = value
+    }
+
+    pow(value: number | Fraction): this {
+        this.power.multiply(value)
+        return this
+    }
+
+    get power(): Fraction {
+        return this.#power
+    }
+
+    set power(value: InputValue<Fraction>) {
+        this.#power = new Fraction(value)
+    }
+
+    primitive(): Factor {
+        throw new NotImplementedError("Method not implemented.")
+    }
+
+    reduce(): Factor {
+        throw new NotImplementedError("Method not implemented.")
+    }
+
+    root(value: number): this {
+        this.power.divide(value)
+        return this
+    }
+
+    sqrt(): this {
+        return this.root(2)
+    }
+
+    subtract(): Factor {
+        throw new MathError("Subtracting two factors is not possible")
+    }
+
+    tableOfSigns(): TABLE_OF_SIGNS {
+        const pow = this.power.clone().reduce()
+        const tos = this.polynom.tableOfSigns()
+
+        // The zero roots becomes defence (d) if the power is negative
+        if (pow.isStrictlyNegative()) {
+            tos.signs = replace_in_array(tos.signs, 'z', 'd')
+        }
+
+        // The - sign becomes
+        // + (plus) if the power num is even and the power den is odd
+        // i (invalid) if the power denominator is even
+        if (pow.denominator % 2 === 0) {
+            // it's an even roots : no negative values!
+            tos.signs = replace_in_array(tos.signs, '-', 'h')
+        } else if (pow.numerator % 2 === 0) {
+            // it's an even power :  negative values becomes positive !
+            tos.signs = replace_in_array(tos.signs, '-', '+')
+        }
+
+
+        return {roots: tos.roots, signs: tos.signs}
+    }
+
+    get variables(): string[] {
+        return this.polynom.variables
+    }
+
+    get withPower(): this {
+        this.#displayMode = FACTOR_DISPLAY.POWER
+        return this
+    }
+
+    get withRoot(): this {
+        this.#displayMode = FACTOR_DISPLAY.ROOT
+        return this
+    }
+
+    zero(): this {
+        this.#polynom.zero()
+        this.#power.one()
+        return this
+    }
+
+    static checkParseAsFactors(str: string): boolean {
+        const splitPlus = splitIfOutsideParentheses(str, "+")
+        if(splitPlus[0]==='') splitPlus.shift()
+        if(splitPlus.length>1) return false
+
+        const splitMinus = splitIfOutsideParentheses(str, "-")
+        if(splitMinus[0]==='') splitMinus.shift()
+        if(splitMinus.length>1) return false
+
+        return true
+    }
+
+    static factorsFromString(value: string, isNumerator = true): Factor[] {
+        if (!Factor.checkParseAsFactors(value)) {
+            return [new Factor(value, isNumerator ? 1 : -1)]
+        }
+
+        const sign = isNumerator ? 1 : -1
+        const factors: Factor[] = []
+
+        // Alternance : facteur parenthésé avec puissance optionnelle | séquence non-parenthésée
+        const regex =
+            /\(([^)]+)\)(?:\^(-?[0-9]+(?:\/[0-9]+)?|\(-?[0-9]+(?:\/[0-9]+)?\)))?|([^(]+)/g
+
+        for (const match of value.matchAll(regex)) {
+            if (match[1] !== undefined) {
+                // Cas : (expr)^puissance
+                const powStr = (match[2] ?? '1')
+                    .replace(/[()]/g, '')
+
+                factors.push(new Factor(
+                    new Polynom(match[1]),
+                    new Fraction(powStr).multiply(sign))
+                )
+            } else if (match[3]?.trim()) {
+                // Cas : monôme ou constante hors parenthèses (ex: 3x^2, 3)
+                factors.push(new Factor(new Polynom(match[3].trim()), new Fraction(sign)))
+            }
+        }
+
+        return factors
+    }
+}
+
+export enum FACTOR_DISPLAY {
+    ROOT,
+    POWER
+}
+