pimath 0.0.68 → 0.0.71

package/src/maths/expressions/expressionFactor.ts

@@ -1,4 +1,5 @@
 import {Expression} from "./internals";
+import {Numeric} from "../numeric";
 
 export abstract class ExpressionFactor {
     constructor(
@@ -30,6 +31,10 @@ export abstract class ExpressionFactor {
         return this.makeTeX()
     }
 
+    get display(): string {
+        return this.makeDisplay()
+    }
+
     get power(): number {
         return this._power;
     }
@@ -62,10 +67,18 @@ export abstract class ExpressionFactor {
 
     abstract makeTeX(numberOfFactors?: number, position?: number): string
 
+    abstract makeDisplay(numberOfFactors?: number, position?: number): string
+
     abstract derivative(variable: string): Expression
 
     abstract integrate(variable: string): Expression
 
+    getArguments(): Expression[] {
+        if (this._argument !== null){
+            return [this.argument]
+        }
+        return []
+    }
     hasVariable(variable?: string): boolean {
 
         if (variable === undefined) {
@@ -78,15 +91,13 @@ export abstract class ExpressionFactor {
         }
 
         return false
-
     }
 
     isNumeric(): boolean {
-        if (this._argument instanceof Expression) {
-            return this.isNumeric()
+        for(let expressionArgument of this.getArguments()){
+            if(!expressionArgument.isNumeric()){return false}
         }
-
-
+        return true
     }
 
     hasRoot(): boolean {
@@ -106,6 +117,28 @@ export abstract class ExpressionFactor {
         return this.texPower(this.texRoot(tex))
     }
 
+    displayPowerAndRoot(display: string): string {
+        return this.displayPower(this.displayRoot(display))
+    }
+
+    displayPower(display: string):string {
+        if (this.hasPower(this.inline)) {
+            return `${display}^(${Math.abs(this.power)})`
+        }
+
+        return display
+    }
+
+    displayRoot(display: string): string {
+        if (this.root === 2) {
+            return `sqrt( ${display} )`
+        } else if (this.root > 2) {
+            return `nthrt(${display},${this.root})`
+        }
+
+        return display
+    }
+
     texPower(tex: string): string {
         if (this.hasPower(this.inline)) {
             return `${tex}^{ ${Math.abs(this.power)} }`
@@ -114,8 +147,12 @@ export abstract class ExpressionFactor {
         return tex
     }
 
-    wrapWithParentheses(tex: string): string {
-        return `\\left( ${tex} \\right)`
+    wrapWithParentheses(tex: string, asTex?: boolean): string {
+        if(asTex===undefined || asTex===true) {
+            return `\\left( ${tex} \\right)`
+        }else{
+            return `( ${tex} )`
+        }
     }
 
     texRoot(tex: string): string {
@@ -135,4 +172,19 @@ export abstract class ExpressionFactor {
 
         return this._argument === 0
     }
+
+    reduce(): ExpressionFactor {
+        let gcd = Numeric.gcd(this.root, this.power)
+
+        if(gcd>1){
+            this.root = this.root/gcd
+            this.power = this.power/gcd
+        }
+
+        for(let expressionArgument of this.getArguments()){
+            expressionArgument.reduce()
+        }
+
+        return this
+    }
 }

package/src/maths/expressions/expressionMember.ts

@@ -24,39 +24,87 @@ export class ExpressionMember {
     }
 
     get tex(): string {
-        let num = this.numerator,
-            den = this.denominator,
-            numTex = num.map((x, index) => x.makeTeX(num.length, index)),
-            denTex = den.map((x, index) => x.makeTeX(den.length, index))
-
-        if (den.length > 0) {
-            return `\\frac{ ${numTex.join("")} }{ ${denTex.join("")} }`
-        } else {
-            return numTex.join("")
-        }
+        return this.toString(true)
     }
 
-    opposed(): ExpressionMember {
-        let firstMember = this.factors[0]
+    get display(): string {
+        return this.toString(false)
+    }
 
-        if (firstMember === undefined) {
-            return this
+    toString(asTex: boolean): string {
+        if (asTex === undefined) {
+            asTex = true
         }
 
-        if (firstMember instanceof ExpFactorNumber) {
-            if (firstMember.hasPower() || firstMember.hasRoot()) {
-                this.factors.unshift(new ExpFactorNumber(-1))
+        let outputArray = this.factors.map(x => {
+            return {
+                value: asTex ? x.tex : x.display,
+                valueWithoutParentheses: asTex ? x.makeTeX(1, 0):x.makeDisplay(1, 0),
+                denominator: x.power < 0,
+                number: (x instanceof ExpFactorNumber)
+            }
+        }), output: string = ''
+
+        while (outputArray.length > 0) {
+            let item = outputArray.shift()
+
+            if (item.denominator) {
+                if (asTex) {
+                    output += `\\frac{1}{ ${item.valueWithoutParentheses} }`
+                } else {
+                    output += `1/(${item.valueWithoutParentheses})`
+                }
             } else {
-                firstMember.number = -firstMember.number
+                if (outputArray.length > 0 && outputArray[0].denominator) {
+                    let item2 = outputArray.shift()
+                    if (asTex) {
+                        output += `\\frac{ ${item.valueWithoutParentheses} }{ ${item2.valueWithoutParentheses} }`
+                    } else {
+                        output += `(${item.valueWithoutParentheses})/(${item2.valueWithoutParentheses})`
+                    }
+                } else {
+                    output += item.value
+
+                    // Check if we need to add the multiplication sign.
+                    if (outputArray.length > 0) {
+                        if (item.number && outputArray[0].number) {
+                            if(outputArray.length>1){
+                                if(!outputArray[1].denominator){
+                                    output +=asTex ? " \\cdot " : "*"
+                                }
+                            }else{
+                                output +=asTex ? " \\cdot " : "*"
+                            }
+
+                        }
+                    }
+                }
             }
-        } else {
-            this.factors.unshift(new ExpFactorNumber(-1))
         }
 
-
-        return this
+        return output
     }
 
+    // opposed(): ExpressionMember {
+    //     let firstMember = this.factors[0]
+    //
+    //     if (firstMember === undefined) {
+    //         return this
+    //     }
+    //
+    //     if (firstMember instanceof ExpFactorNumber) {
+    //         if (firstMember.hasPower() || firstMember.hasRoot()) {
+    //             this.factors.unshift(new ExpFactorNumber(-1))
+    //         } else {
+    //             firstMember.number = -firstMember.number
+    //         }
+    //     } else {
+    //         this.factors.unshift(new ExpFactorNumber(-1))
+    //     }
+    //
+    //     return this
+    // }
+
     add(value: ExpressionFactor): ExpressionMember {
         this._factors.push(value)
         return this
@@ -111,4 +159,75 @@ export class ExpressionMember {
 
         return true
     }
+
+    /**
+     * Returns the "coefficient", ie a member with only numeric values factors.
+     */
+    coefficient(): ExpressionMember {
+        let EM = new ExpressionMember()
+
+        for (let factor of this.factors) {
+            if (factor.isNumeric()) {
+                EM.add(factor)
+            }
+        }
+        return EM
+    }
+
+    /**
+     * Returns a member with all factors containing a literal part.
+     */
+    literal(): ExpressionMember {
+        let EM = new ExpressionMember()
+
+        for (let factor of this.factors) {
+            if (!factor.isNumeric()) {
+                EM.add(factor)
+            }
+        }
+        return EM
+    }
+
+    similarTo(member: ExpressionMember): boolean {
+        // TODO: identify two "similar" member, ie with the same literal parts.
+        return true
+    }
+
+    reduce(): ExpressionMember {
+        // Merge all ExpFactorNumbers that are number
+        let numerator = new ExpFactorNumber(1),
+            denominator = new ExpFactorNumber(1, -1),
+            literal: ExpressionFactor[] = []
+
+        for (let factor of this.factors) {
+            // Reduce the factor
+            factor.reduce()
+
+            if (factor instanceof ExpFactorNumber && factor.root === 1) {
+                if (factor.power > 0) {
+                    numerator.number = numerator.number * (factor.number ** factor.power)
+                } else {
+                    denominator.number = denominator.number * (factor.number ** (-factor.power))
+                }
+            } else {
+                literal.push(factor)
+            }
+        }
+
+        let EM = new ExpressionMember()
+
+        // There is a numerator
+        if(numerator.number!==1){
+            EM.addFactors(numerator)
+        }
+
+        // No denominator.
+        if(denominator.number!==1){
+            EM.addFactors(denominator)
+        }
+
+        // Add the other factors
+        EM.addFactors(...literal)
+        return EM
+    }
 }

package/src/maths/expressions/expressionParser.ts

@@ -25,6 +25,7 @@ export class ExpressionParser {
 
     constructor(value: string) {
         this._expression = this.parse(value)
+
     }
 
     get expression(): Expression {
@@ -92,26 +93,13 @@ export class ExpressionParser {
                     let a = stack.pop()
 
                     if (item.token === 'sqrt') {
-                        let b = stack.pop()
-                        // Transform the argument to expression
-                        if(! (a instanceof Expression)){a = new Expression(a)}
-                        stack.push(new ExpFactor(a, 1, 2))
+                        stack.push(this.tokenOperationSqrt(a))
                     } else if (item.token === 'nthrt') {
-                        // TODO: suppose it's a number
-                        let b = stack.pop()
-                        // Transform the argument to expression
-                        if(! (b instanceof Expression)){b = new Expression(b)}
-                        // the "a" value is the nth root. It must be a number
-                        let n = 2
-                        if(a instanceof ExpFactorNumber){
-                           n = a.number
-                        }else{
-                            throw "The nth root value must be a number, not " + a.tex
-                        }
-
-                        stack.push(new ExpFactor(b, 1, n))
+                        stack.push(this.tokenOperationRoot(a, stack.pop()))
                     } else if (item.token in TRIGONOMETRIC) {
-                        if(! (a instanceof Expression)){a = new Expression(a)}
+                        if (!(a instanceof Expression)) {
+                            a = new Expression(a)
+                        }
                         stack.push(new ExpFactorTrigo(item.token, a))
                     }
                     break
@@ -158,48 +146,56 @@ export class ExpressionParser {
     }
 
     private tokenOperationMultiply(a: Expression | ExpressionMember | ExpressionFactor, b: Expression | ExpressionMember | ExpressionFactor): ExpressionMember {
+        let EM = new ExpressionMember()
         if (a instanceof Expression) {
-            a = new ExpFactor(a)
+            EM.addFactors(new ExpFactor(a))
+            // a = new ExpFactor(a)
         } else if (a instanceof ExpressionMember) {
-            a = new ExpFactor(new Expression(a))
+            // a.add()
+            EM.addFactors(...a.factors)
+            // a = new ExpFactor(new Expression(a))
         } else if (a instanceof ExpressionFactor) {
             // Do nothing
+            EM.addFactors(a)
         }
 
         if (b instanceof Expression) {
-            b = new ExpFactor(b)
+            // b = new ExpFactor(b)
+            EM.addFactors(new ExpFactor(b))
         } else if (b instanceof ExpressionMember) {
-            b = new ExpFactor(new Expression(b))
+            // b = new ExpFactor(new Expression(b))
+            EM.addFactors(...b.factors)
         } else if (b instanceof ExpressionFactor) {
             // Do nothing
+            EM.addFactors(b)
         }
 
-        // a and b are ExpressionFactors - multiply them
-
-        return new ExpressionMember(a, b)
-
+        return EM
     }
 
     private tokenOperationDivide(a: Expression | ExpressionMember | ExpressionFactor, b: Expression | ExpressionMember | ExpressionFactor): ExpressionMember {
+        let EM = new ExpressionMember()
+
         if (a instanceof Expression) {
-            a = new ExpFactor(a)
+            EM.addFactors(new ExpFactor(a))
         } else if (a instanceof ExpressionMember) {
-            a = new ExpFactor(new Expression(a))
+            EM.addFactors(...a.factors)
         } else if (a instanceof ExpressionFactor) {
             // Do nothing
+            EM.addFactors(a)
         }
 
         if (b instanceof Expression) {
-            b = new ExpFactor(b, -1)
+            EM.addFactors(new ExpFactor(b, -1))
         } else if (b instanceof ExpressionMember) {
-            b = new ExpFactor(new Expression(b), -1)
+            EM.addFactors(new ExpFactor(new Expression(b), -1))
         } else if (b instanceof ExpressionFactor) {
             // Do nothing
             b.power = -b.power
+            EM.addFactors(b)
         }
 
-        // a and b are ExpressionFactors - multiply them
-        return new ExpressionMember(a, b)
+        return EM
     }
 
     private tokenOperationPower(a: Expression | ExpressionMember | ExpressionFactor, b: Expression | ExpressionMember | ExpressionFactor): ExpressionFactor {
@@ -209,7 +205,13 @@ export class ExpressionParser {
             a = new Expression(a)
         } else if (a instanceof ExpressionFactor) {
             // Make a new factor of itself
-            a = new Expression(new ExpressionMember(a))
+            console.log(a)
+            if (a.power === 1 && b instanceof ExpFactorNumber) {
+                a.power = b.value
+                return a
+            } else {
+                a = new Expression(new ExpressionMember(a))
+            }
         }
 
         // b can be :
@@ -246,4 +248,48 @@ export class ExpressionParser {
 
     }
 
+    private tokenOperationSqrt(a: Expression | ExpressionMember | ExpressionFactor): Expression | ExpressionFactor {
+
+            // Transform the argument to expression
+            if (a instanceof Expression) {
+                return new ExpFactor(a, 1, 2)
+            } else if (a instanceof ExpressionMember) {
+                if (a.factors.length === 1 && !a.factors[0].hasPower()) {
+                    a.factors[0].root = 2
+                    return a.factors[0]
+                } else {
+                    return new ExpFactor(new Expression(a), 1, 2)
+                }
+            } else if (a instanceof ExpressionFactor) {
+                if (!a.hasPower()) {
+                    a.root = 2
+                    return a
+                } else {
+                    return new ExpFactor(new Expression(a), 1, 2)
+                }
+            }
+        // Fallback
+        return a
+    }
+
+    private tokenOperationRoot(a:Expression | ExpressionMember | ExpressionFactor, b:Expression | ExpressionMember | ExpressionFactor): ExpFactor {
+        // a is the power
+        // b is the argument
+
+
+
+        // Transform the argument to expression
+        if (!(b instanceof Expression)) {
+            b = new Expression(b)
+        }
+        // the "a" value is the nth root. It must be a number
+        let n = 2
+        if (a instanceof ExpFactorNumber) {
+            n = a.number
+        } else {
+            throw "The nth root value must be a number, not " + a.tex
+        }
+
+        return new ExpFactor(b, 1, n)
+    }
 }

package/src/maths/expressions/factors/ExpFactor.ts

@@ -1,5 +1,4 @@
-import {Expression} from "../internals";
-import {ExpressionFactor} from "../internals";
+import {Expression, ExpressionFactor} from "../internals";
 
 
 export class ExpFactor extends ExpressionFactor {
@@ -13,14 +12,28 @@ export class ExpFactor extends ExpressionFactor {
     }
 
     makeTeX(numberOfFactors?: number, position?: number): string {
-        // If there is a root value, no need to make further checks
         // TODO: no need to wrap if it's single ?
-        if(this.hasRoot() || this.hasPower()){
+        if (this.hasRoot() || this.hasPower()) {
             return this.texPower(this.texRoot(
-                this.wrapWithParentheses(this.argument.tex)
+                this.argument.tex
+                // this.wrapWithParentheses(this.argument.tex)
             ))
         }
 
-        return this.argument.isFactor() ? this.argument.tex: this.wrapWithParentheses(this.argument.tex)
+        if (numberOfFactors === 1) {
+            return this.argument.tex
+        } else {
+            return this.argument.isFactor() ? this.argument.tex : this.wrapWithParentheses(this.argument.tex)
+        }
+    }
+
+    makeDisplay(numberOfFactors?: number, position?: number): string {
+        if (this.hasRoot() || this.hasPower()) {
+            return this.displayPower(this.texRoot(
+                this.wrapWithParentheses(this.argument.display, false)
+            ))
+        }
+
+        return this.argument.isFactor() ? this.argument.display : this.wrapWithParentheses(this.argument.display)
     }
 }

package/src/maths/expressions/factors/ExpFactorConstant.ts

@@ -53,4 +53,8 @@ export class ExpFactorConstant extends ExpressionFactor {
     hasVariable(variable?: string): boolean {
         return false
     }
+
+    makeDisplay(numberOfFactors?: number, position?: number): string {
+        return this._constant;
+    }
 }

package/src/maths/expressions/factors/ExpFactorExponential.ts

@@ -16,4 +16,11 @@ export class ExpFactorExponential extends ExpressionFactor {
 
         return this.texPowerAndRoot(tex)
     }
+
+    makeDisplay(numberOfFactors?: number, position?: number): string {
+        let display: string = `e^( ${ this.argument.tex } )`
+
+        return this.displayPowerAndRoot(display)
+    }
+
 }

package/src/maths/expressions/factors/ExpFactorNumber.ts

@@ -1,8 +1,8 @@
-import {Expression} from "../internals";
-import {ExpressionFactor} from "../internals";
+import {Expression, ExpressionFactor} from "../internals";
 
 export class ExpFactorNumber extends ExpressionFactor {
     private _number: number
+
     constructor(value: number, power?: number, root?: number) {
         super(null, power, root);
 
@@ -13,8 +13,8 @@ export class ExpFactorNumber extends ExpressionFactor {
         this._number = value
     }
 
-    get value():number {
-        return Math.pow(this._number, this.root/this.root)
+    get value(): number {
+        return Math.pow(this._number, this.root / this.root)
     }
 
     get number(): number {
@@ -30,6 +30,10 @@ export class ExpFactorNumber extends ExpressionFactor {
         return this.texPower(this.texRoot(this._number.toString()))
     }
 
+    makeDisplay(numberOfFactors?: number, position?: number): string {
+        return this.displayPower(this.displayRoot(this._number.toString()))
+    }
+
     derivative(variable: string): Expression {
         return undefined;
     }
@@ -41,4 +45,28 @@ export class ExpFactorNumber extends ExpressionFactor {
     hasVariable(variable?: string): boolean {
         return false
     }
+
+    reduce(): ExpressionFactor {
+        // Reduce the power / root value
+        super.reduce()
+
+        if (this.power > 1) {
+            this.number = this.number ** this.power
+            this.power = 1
+        }
+        if (this.power < -1) {
+            this.number = this.number ** (-this.power)
+            this.power = -1
+        }
+
+        if(this.root>1){
+            // Maybe it's a perfect root ?
+            if(Number.isSafeInteger(Math.pow(this.number, 1/this.root))){
+                this.number = Math.pow(this.number, 1/this.root)
+                this.root = 1
+            }
+        }
+
+        return this
+    }
 }

package/src/maths/expressions/factors/ExpFactorPower.ts

@@ -2,11 +2,19 @@ import {Expression} from "../internals";
 import {ExpressionFactor} from "../internals";
 
 export class ExpFactorPower extends ExpressionFactor {
-private powerArgument: Expression
+    get powerArgument(): Expression {
+        return this._powerArgument;
+    }
+
+    set powerArgument(value: Expression) {
+        this._powerArgument = value;
+    }
+
+    private _powerArgument: Expression
     constructor(radical: Expression, power: Expression, power2?: number, root?:number) {
         super(radical, power2, root);
 
-        this.powerArgument = power
+        this._powerArgument = power
     }
     derivative(variable: string): Expression {
         return undefined
@@ -17,8 +25,18 @@ private powerArgument: Expression
     }
 
     makeTeX(): string {
-        let tex: string = `{ ${ this.argument.tex } }^{ ${this.powerArgument.tex } }`
+        let tex: string = `{ ${ this.argument.tex } }^{ ${this._powerArgument.tex } }`
 
         return this.texPowerAndRoot(this.wrapWithParentheses(tex))
     }
+
+    getArguments(): Expression[] {
+        return [this.argument, this.powerArgument]
+    }
+
+    makeDisplay(numberOfFactors?: number, position?: number): string {
+        let display: string = `( ${ this.argument.display } )^( ${this._powerArgument.display } )`
+
+        return this.displayPowerAndRoot(this.wrapWithParentheses(display, false))
+    }
 }

package/src/maths/expressions/factors/ExpFactorTrigo.ts

@@ -12,7 +12,6 @@ export enum TRIGONOMETRIC {
     acot='acot'
 }
 export class ExpFactorTrigo extends ExpressionFactor {
-
     private _trigo: string
     constructor(trigo: string, argument: Expression, power?: number, root?: number) {
 
@@ -41,4 +40,14 @@ export class ExpFactorTrigo extends ExpressionFactor {
         tex+= `\\left( ${this.argument.tex} \\right)`
         return this.texRoot(tex);
     }
+
+    makeDisplay(numberOfFactors?: number, position?: number): string {
+        let display = `${this._trigo}`
+        if(this.root>1){
+            display += `^( ${this.root} )`
+        }
+
+        display+= `( ${this.argument.display} )`
+        return this.displayRoot(display);
+    }
 }

package/src/maths/expressions/factors/ExpFactorVariable.ts

@@ -26,6 +26,11 @@ export class ExpFactorVariable extends ExpressionFactor {
         return this.texPower(this.texRoot(this._variable))
     }
 
+    makeDisplay(numberOfFactors?: number, position?: number): string {
+        return this.displayPower(this.displayRoot(this._variable))
+    }
+
+
     derivative(variable: string): Expression {
         return undefined;
     }

package/src/maths/expressions/polynomexp.bkp.ts

@@ -162,7 +162,6 @@ export class PolynomExp {
         this._factors = []
         if (values !== undefined) {
             for (const factor of values) {
-                console.log('ADDING', factor.tex)
                 this._factors.push({
                     factors: factor,
                     positive: true