pimath 0.0.69 → 0.0.72

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

package/src/maths/shutingyard.ts

@@ -189,6 +189,8 @@ export class Shutingyard {
     }
 
     normalize(expr: string): string {
+        if(expr.length===1){return expr}
+
         // Get the list of function token.
         let fnToken: string[] = [],
             kToken: string[] = []
@@ -207,6 +209,8 @@ export class Shutingyard {
         kToken.sort((a, b) => b.length - a.length)
 
 
+
+
         let normalizedExpr: string = "",
             i = 0,
             crtToken,
@@ -370,7 +374,6 @@ export class Shutingyard {
         // Normalize the input if required.
         if (this._uniformize) expr = this.normalize(expr)
 
-
         let securityLoopLvl1 = 50,
             securityLoopLvl2_default = 50,
             securityLoopLvl2;

package/tests/coefficients/fraction.test.ts

@@ -75,6 +75,17 @@ describe("Fraction static functions", ()=>{
 
         expect(Fraction.average(...list).tex).to.be.equal('\\frac{ 19 }{ 10 }')
     })
+
+    it('should multiply and notreduce', function () {
+        let list = [
+            new Fraction('1/2'),
+            new Fraction('4/3'),
+            2.5,
+            3
+        ]
+
+        console.log(new Fraction().xMultiply(...list))
+    });
 })
 
 describe("Evaluate fraction", () => {

package/tests/expressions/expressions.test.ts

@@ -17,10 +17,31 @@ describe('Expressions tests', () => { // the tests container
         // let a = new ExpressionParser('3x^(2/3)+5').expression
         // let a = new ExpressionParser('3x(x+4)').expression
         // let a = new ExpressionParser('sin(cos(3picos(3pi)-5))+sqrt(e-sin(3pi/2))').expression
-        let a = new ExpressionParser('3+nthrt(x-3,5)').expression
-        console.log('TeX output: ', a.tex)
-        console.log(a.structure())
+        // let a = new ExpressionParser('3-nthrt(x-3,5)').expression
+        // console.log(a.isPolynom())
+        // let b = new ExpressionParser('3/2x^2-5x+7').expression
+        // console.log(b.tex, b.isPolynom())
+        // console.log(b.members[0].member.coefficient().tex)
+        // console.log(b.members[0].member.litteral().tex)
+        // console.log(b.structure())
+        //
 
+        // let c = new ExpressionParser('3/2x^2+5/3x-7').expression
+        // console.log(c.tex)
+        // console.log(c.display)
+
+        // let d = new ExpressionParser('sqrt(16)*sqrt(15^4)+9/15').expression
+        let d = new ExpressionParser('nthrt(16,4)').expression
+        console.log(d.tex)
+        console.log(d.members[0].member.reduce().tex)
+        console.log(d.structure())
+        // console.log(d.display)
+
+        // console.log(d.structure())
+        // console.log(c.display)
+        // console.log(c.members[0].member.literal().factors.length)
+        // console.log(c.members[0].member.reduce().tex);
+        // console.log(c.members[1].member.reduce().tex);
     })
 
     it('should make some operations', ()=>{

package/tests/geometry/circle.test.ts

@@ -60,4 +60,10 @@ describe('Circle', function () {
 
         expect(pts.map(x=>x.x.display + ',' + x.y.display)).to.have.all.members([ '3,0', '3,-8', '7,-4', '-1,-4' ])
     });
+
+    it('should calculate the circle from center and radius', function(){
+        let circle = new Circle("x^2+6x+y^2-8y+12=0")
+
+        console.log(circle.tex)
+    })
 });

package/esm/maths/expressions/factors/ExpFactorSin.d.ts

@@ -1,7 +0,0 @@
-import { ExpressionFactor } from "../expressionFactor";
-import { Expression } from "../expression";
-export declare class ExpFactorSin extends ExpressionFactor {
-    derivative(variable: string): Expression;
-    integrate(variable: string): Expression;
-    makeTeX(): string;
-}