pimath 0.1.40 → 0.2.1

package/src/algebra/logicalset.ts

@@ -33,58 +33,6 @@ export class LogicalSet {
         return this
     }
 
-    evaluate(values: Record<string, boolean>): boolean {
-        // Add missing key(s) and set them as false by default.
-        this.variables.forEach(key => {
-            if (!Object.hasOwn(values, key)) {
-                values[key] = false
-            }
-        })
-
-        const stack: boolean[] = []
-        for (const token of this.#rpn) {
-            console.log(token)
-            if (token.tokenType === 'variable') {
-                stack.push(values[token.token])
-            } else if (token.tokenType === 'operation') {
-                if (token.token === '!') {
-                    // need only one item from stack
-                    if (stack.length >= 1) {
-                        const a = stack.pop()
-                        stack.push(!a)
-                    } else {
-                        return false
-                    }
-                } else {
-                    // All other operations needs two items from stack
-                    const a = stack.pop()
-                    const b = stack.pop()
-                    if (a !== undefined && b !== undefined) {
-                        switch (token.token) {
-                            case "&":
-                                stack.push(a && b)
-                                break
-                            case "|":
-                                stack.push(a || b)
-                                break
-                            case "-":
-                                return false
-                        }
-
-                    } else {
-                        return false
-                    }
-                }
-            }
-        }
-
-        return stack.length === 1 && stack[0]
-    }
-
-    get rpn(): { token: string, tokenType: string }[] {
-        return this.#rpn
-    }
-
     get tex(): string {
         const varStack: { token: string, tokenType: string }[] = []
 
@@ -157,6 +105,57 @@ export class LogicalSet {
         return varStack[0].token
     }
 
+    evaluate(values: Record<string, boolean>): boolean {
+        // Add missing key(s) and set them as false by default.
+        this.variables.forEach(key => {
+            if (!Object.hasOwn(values, key)) {
+                values[key] = false
+            }
+        })
+
+        const stack: boolean[] = []
+        for (const token of this.#rpn) {
+            if (token.tokenType === 'variable') {
+                stack.push(values[token.token])
+            } else if (token.tokenType === 'operation') {
+                if (token.token === '!') {
+                    // need only one item from stack
+                    if (stack.length >= 1) {
+                        const a = stack.pop()
+                        stack.push(!a)
+                    } else {
+                        return false
+                    }
+                } else {
+                    // All other operations needs two items from stack
+                    const a = stack.pop()
+                    const b = stack.pop()
+                    if (a !== undefined && b !== undefined) {
+                        switch (token.token) {
+                            case "&":
+                                stack.push(a && b)
+                                break
+                            case "|":
+                                stack.push(a || b)
+                                break
+                            case "-":
+                                return false
+                        }
+
+                    } else {
+                        return false
+                    }
+                }
+            }
+        }
+
+        return stack.length === 1 && stack[0]
+    }
+
+    get rpn(): { token: string, tokenType: string }[] {
+        return this.#rpn
+    }
+
     get variables(): string[] {
         return this.#rpn
             .filter(value => value.tokenType === 'variable')

package/src/algebra/monom.ts

@@ -10,8 +10,7 @@ import type {
     IPiMathObject,
     literalType
 } from "../pimath.interface"
-import {Fraction} from "../coefficients/fraction"
-import {NthRoot} from "../coefficients/nthRoot"
+import {Fraction} from "../coefficients"
 import {Numeric} from "../numeric"
 
 import {ShutingYard, ShutingyardType, type Token} from "piexpression"
@@ -44,23 +43,30 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
         this.#coefficient = new Fraction()
         this.#literal = {}
 
-        if (typeof inputStr === 'string') {
-            if(!isNaN(Number(inputStr))){
-                this.#coefficient = new Fraction(Number(inputStr))
-            }else {
-                this.#shutingYardToReducedMonom(inputStr)
-            }
-        } else if (typeof inputStr === 'number') {
-            this.#coefficient = new Fraction(inputStr)
-        } else if (inputStr instanceof Fraction) {
-            this.#coefficient = inputStr.clone()
-        } else if (inputStr instanceof Monom) {
+        if (inputStr instanceof Monom) {
             this.#coefficient = inputStr.#coefficient.clone()
 
             // Copy the literal parts
             this.#cloneLiteral(inputStr)
+            return this
         }
 
+        if (inputStr instanceof Fraction) {
+            this.#coefficient = inputStr.clone()
+            return this
+        }
+
+        if (typeof inputStr === 'number') {
+            this.#coefficient = new Fraction(inputStr)
+            return this
+        }
+
+
+        if (!isNaN(Number(inputStr))) {
+            this.#coefficient = new Fraction(Number(inputStr))
+        } else {
+            this.#shutingYardToReducedMonom(inputStr)
+        }
         return this
     }
 
@@ -83,8 +89,6 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
      * Get the tex output of the monom
      */
     public get tex(): string {
-        // TODO: display with square root !
-        // TODO: Refactor to make it more readable
         let L = ''
         const letters = Object.keys(this.#literal).sort()
 
@@ -92,7 +96,7 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
             if (this.#literal[letter].isNotZero()) {
                 L += letter
                 if (this.#literal[letter].isNotEqual(1)) {
-                    L += `^{ ${this.#literal[letter].tfrac.tex } }`
+                    L += `^{ ${this.#literal[letter].tfrac.tex} }`
                 }
             }
         }
@@ -265,12 +269,8 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
      * Derivative the monom
      * @param letter
      */
-    public derivative = (letter?: string): Monom => {
+    public derivative = (letter = 'x'): Monom => {
         // No setLetter given - assume it's the setLetter 'x'
-        if (letter === undefined) {
-            letter = 'x'
-        }
-
         if (this.hasVariable(letter)) {
             const d = this.#literal[letter].clone(),
                 dM = this.clone()
@@ -383,11 +383,6 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
                 return this.#evaluateAsNumeric(values.value)
             }
 
-            // If the value is a NthRoot, return undefined
-            if (values instanceof NthRoot) {
-                return new Fraction().invalid()
-            }
-
             // If the value is a number, return the numeric value
             if (typeof values === 'number') {
                 return this.#evaluateAsNumeric(values)
@@ -414,10 +409,6 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
             return this.evaluate(tmpValues)
         }
 
-        if (values instanceof NthRoot) {
-            return new Fraction().invalid()
-        }
-
         if (typeof values === 'object') {
             if (this.variables.length === 0) {
                 return this.coefficient
@@ -443,7 +434,7 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
         return Object.hasOwn(this.#literal, letter ?? 'x')
     }
 
-    public integrate(a: InputValue<Fraction>, b: InputValue<Fraction>, letter?: string  ): Fraction {
+    public integrate(a: InputValue<Fraction>, b: InputValue<Fraction>, letter?: string): Fraction {
         const primitive = this.primitive(letter)
 
         return (primitive.evaluate(b) as Fraction)
@@ -583,30 +574,11 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
         this.#literal = L
     }
 
-    /**
-     * Get the literal square roots of the Monom.
-     * @returns {literalType<Fraction>}
-     */
-    public get literalSqrt(): literalType<Fraction> {
-        // TODO: used in Polynom._factorize2ndDegree : remove it from here ?
-        if (this.isLiteralSquare()) {
-            const L: literalType<Fraction> = {}
-            for (const key in this.#literal) {
-                L[key] = this.#literal[key].clone().sqrt()
-            }
-            return L
-        } else {
-            return this.#literal
-        }
-    }
-
     /**
      * Set the literal part of the monom from a string
      * @param inputStr  String like x^2y^3
      */
     public set literalStr(inputStr: string) {
-        // TODO : parse using ShutingYard tree !
-
         // Match all x^n
         for (const v of [...inputStr.matchAll(/([a-z])\^([+-]?[0-9]+)/g)]) {
             // Create the default letter entry if necessary.
@@ -615,7 +587,6 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
             }
 
             // Add the new value.
-            // TODO: actually, it adds only numeric value
             this.#literal[v[1]].add(+v[2])
         }
 
@@ -719,12 +690,7 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
         return this
     }
 
-    public primitive = (letter?: string): Monom => {
-        // TODO: derivative including the ln value => implies creating different monom system ?
-        if (letter === undefined) {
-            letter = 'x'
-        }
-
+    public primitive = (letter = 'x'): Monom => {
         // Zero monom
         const M = this.clone()
         let degree: Fraction
@@ -880,10 +846,6 @@ export class Monom implements IPiMathObject<Monom>, IExpression<Monom>, IAnalyse
             return this.#evaluateAsNumeric(tmpValues)
         }
 
-        if (values instanceof NthRoot) {
-            return NaN
-        }
-
         if (typeof values === 'object') {
             if (this.variables.length === 0) {
                 return this.coefficient.value

package/src/algebra/operations.ts

@@ -2,7 +2,6 @@ import type {IExpressionMultiply, IPiMathObject} from "../pimath.interface"
 
 // TODO: create other operation_** to make things more generic !
 export function operation_pow<T extends IPiMathObject<T> & IExpressionMultiply<T>>(item: T, value: number): T {
-    // TODO: Implement the operation_pow to other classes
     if (!Number.isSafeInteger(value)) {
         throw new Error('Can only raise item by an integer')
     }

package/src/algebra/polyFactor.ts

@@ -5,7 +5,6 @@ import type {
     InputAlgebra,
     InputValue,
     IPiMathObject,
-    ISolution,
     literalType,
     POLYFACTOR_TABLE_OF_SIGNS,
     TABLE_OF_SIGNS_VALUES
@@ -24,12 +23,12 @@ export class PolyFactor implements IPiMathObject<PolyFactor>,
     #displayMode: FACTOR_DISPLAY = FACTOR_DISPLAY.POWER
     #factors: Factor[] = []
 
-    constructor(...values: (Factor | PolyFactor)[]) {
+    constructor(...values: (InputAlgebra<Polynom> | Factor | PolyFactor)[]) {
         this.parse(...values)
         return this
     }
 
-    public parse(...values: (Factor | PolyFactor)[]): this {
+    public parse(...values: (InputAlgebra<Polynom> | Factor | PolyFactor)[]): this {
         // Init the factors list
         this.#factors = []
 
@@ -363,9 +362,9 @@ export class PolyFactor implements IPiMathObject<PolyFactor>,
         return []
     }
 
-    public getZeroes(): ISolution[] {
+    public getZeroes(): Solution[] {
         // Calculate the list of roots (ordered, unique)
-        const roots: ISolution[] = ([] as ISolution[])
+        const roots: Solution[] = ([] as Solution[])
             .concat(...this.#factors.map(x => x.polynom.getZeroes()))
         // .concat(...tos.map(x => x.roots))
 
@@ -530,6 +529,7 @@ export class PolyFactor implements IPiMathObject<PolyFactor>,
                 return {factor: new Factor(factor), ...factor.tableOfSigns()}
             })
 
+        
         // Build the table of signs with extra roots for each factors.
         factors.forEach(item => {
             // Create the new signs row