pimath 0.0.64 → 0.0.67

package/src/maths/expressions/expressionParser.ts

@@ -0,0 +1,249 @@
+import {
+    ExpFactor,
+    ExpFactorConstant,
+    ExpFactorNumber,
+    ExpFactorPower,
+    ExpFactorTrigo,
+    ExpFactorVariable,
+    Expression,
+    ExpressionFactor,
+    ExpressionMember,
+    Shutingyard,
+    ShutingyardMode,
+    ShutingyardType,
+    TRIGONOMETRIC
+} from "./internals";
+
+function dlog(...values: unknown[]): void {
+    if (false) {
+        console.log(...values)
+    }
+}
+
+export class ExpressionParser {
+    private _expression: Expression
+
+    constructor(value: string) {
+        this._expression = this.parse(value)
+    }
+
+    get expression(): Expression {
+        return this._expression
+    }
+
+
+    private parse(value: string): Expression {
+        let expr: Expression[],
+            SY = new Shutingyard(ShutingyardMode.EXPRESSION).parse(value),
+            rpn = SY.rpn,
+            stack: (Expression | ExpressionMember | ExpressionFactor)[] = []
+
+        dlog(SY.rpn)
+        dlog(SY.normalize(value))
+        for (let item of rpn) {
+            dlog('BEFORE', item.token, stack.map(s => s.tex))
+            switch (item.tokenType) {
+                case ShutingyardType.COEFFICIENT:
+                    stack.push(new ExpFactorNumber(+item.token))
+                    break
+
+                case ShutingyardType.CONSTANT:
+                    stack.push(new ExpFactorConstant(item.token))
+                    break
+
+                case ShutingyardType.VARIABLE:
+                    stack.push(new ExpFactorVariable(item.token))
+                    break
+
+                case ShutingyardType.OPERATION:
+                    // for an operation, the stack length should be two
+                    if (stack.length >= 2) {
+                        let b = stack.pop(),
+                            a = stack.pop()
+                        // dlog('OPERATION A - B', stack.map(s=>s.tex))
+                        switch (item.token) {
+                            case "+":
+                                stack.push(this.tokenOperationPlus(a, b))
+                                break
+                            case "-":
+                                stack.push(this.tokenOperationMinus(a, b))
+                                break
+
+                            case "*":
+                                stack.push(this.tokenOperationMultiply(a, b))
+                                break;
+
+                            case "/":
+                                stack.push(this.tokenOperationDivide(a, b))
+                                break;
+
+                            case "^":
+                                stack.push(this.tokenOperationPower(a, b))
+                                break;
+                        }
+
+                    } else {
+                        // TODO: handle stack size of one when applying an operation
+                    }
+
+                    break
+
+                case ShutingyardType.FUNCTION:
+                    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))
+                    } 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))
+                    } else if (item.token in TRIGONOMETRIC) {
+                        if(! (a instanceof Expression)){a = new Expression(a)}
+                        stack.push(new ExpFactorTrigo(item.token, a))
+                    }
+                    break
+
+                default:
+                    throw('Something went wrong while parsing ' + value + ' at ' + item.token)
+            }
+
+            dlog('AFTER', item.token, stack.map(s => s.tex))
+            dlog('----------')
+        }
+
+
+        // Build the output expression.
+        let output = new Expression()
+        for (let item of stack) {
+            if (item instanceof Expression) {
+                output.addMembers(...item.members)
+            } else if (item instanceof ExpressionMember) {
+                output.addMembers(item)
+            } else if (item instanceof ExpressionFactor) {
+                output.addMembers(item)
+            }
+        }
+
+        return output
+        // TODO: in the stack, there might be an Expression, ExpressionMember or an ExpressionFactor.
+        // @ts-ignore
+        // return new Expression(...stack.map(
+        //     item=>{
+        //         return item instanceof ExpressionFactor ? new ExpressionMember(item) : item;
+        //     }
+        // ))
+    }
+
+
+    private tokenOperationPlus(a: Expression | ExpressionMember | ExpressionFactor, b: Expression | ExpressionMember | ExpressionFactor): Expression {
+
+        if (a instanceof ExpressionMember || a instanceof ExpressionFactor) {
+            a = new Expression(a)
+        }
+
+        return a.add(b)
+    }
+
+    private tokenOperationMultiply(a: Expression | ExpressionMember | ExpressionFactor, b: Expression | ExpressionMember | ExpressionFactor): ExpressionMember {
+        if (a instanceof Expression) {
+            a = new ExpFactor(a)
+        } else if (a instanceof ExpressionMember) {
+            a = new ExpFactor(new Expression(a))
+        } else if (a instanceof ExpressionFactor) {
+            // Do nothing
+        }
+
+        if (b instanceof Expression) {
+            b = new ExpFactor(b)
+        } else if (b instanceof ExpressionMember) {
+            b = new ExpFactor(new Expression(b))
+        } else if (b instanceof ExpressionFactor) {
+            // Do nothing
+        }
+
+        // a and b are ExpressionFactors - multiply them
+
+        return new ExpressionMember(a, b)
+
+    }
+
+    private tokenOperationDivide(a: Expression | ExpressionMember | ExpressionFactor, b: Expression | ExpressionMember | ExpressionFactor): ExpressionMember {
+        if (a instanceof Expression) {
+            a = new ExpFactor(a)
+        } else if (a instanceof ExpressionMember) {
+            a = new ExpFactor(new Expression(a))
+        } else if (a instanceof ExpressionFactor) {
+            // Do nothing
+        }
+
+        if (b instanceof Expression) {
+            b = new ExpFactor(b, -1)
+        } else if (b instanceof ExpressionMember) {
+            b = new ExpFactor(new Expression(b), -1)
+        } else if (b instanceof ExpressionFactor) {
+            // Do nothing
+            b.power = -b.power
+        }
+
+        // a and b are ExpressionFactors - multiply them
+        return new ExpressionMember(a, b)
+    }
+
+    private tokenOperationPower(a: Expression | ExpressionMember | ExpressionFactor, b: Expression | ExpressionMember | ExpressionFactor): ExpressionFactor {
+        if (a instanceof Expression) {
+            // Do nothing
+        } else if (a instanceof ExpressionMember) {
+            a = new Expression(a)
+        } else if (a instanceof ExpressionFactor) {
+            // Make a new factor of itself
+            a = new Expression(new ExpressionMember(a))
+        }
+
+        // b can be :
+        // number       3
+        // any other expression
+        //
+        if (b instanceof Expression) {
+            // Do nothing
+        } else if (b instanceof ExpressionMember) {
+            b = new Expression(b)
+        } else if (b instanceof ExpFactorNumber) {
+            return new ExpFactor(a, b.value)
+        } else if (b instanceof ExpressionFactor) {
+            b = new Expression(new ExpressionMember(b))
+        }
+
+        return new ExpFactorPower(a, b)
+    }
+
+    private tokenOperationMinus(a: Expression | ExpressionMember | ExpressionFactor, b: Expression | ExpressionMember | ExpressionFactor): Expression {
+        if (a instanceof ExpressionMember) {
+            a = new Expression(a)
+        } else if (a instanceof ExpressionFactor) {
+            a = new Expression(new ExpressionMember(a))
+        }
+
+        if (b instanceof ExpressionMember) {
+            b = new Expression(b)
+        } else if (b instanceof ExpressionFactor) {
+            b = new Expression(new ExpressionMember(b))
+        }
+
+        return a.subtract(b)
+
+    }
+
+}

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

@@ -0,0 +1,26 @@
+import {Expression} from "../internals";
+import {ExpressionFactor} from "../internals";
+
+
+export class ExpFactor extends ExpressionFactor {
+
+    derivative(variable: string): Expression {
+        return undefined;
+    }
+
+    integrate(variable: string): Expression {
+        return undefined;
+    }
+
+    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()){
+            return this.texPower(this.texRoot(
+                this.wrapWithParentheses(this.argument.tex)
+            ))
+        }
+
+        return this.argument.isFactor() ? this.argument.tex: this.wrapWithParentheses(this.argument.tex)
+    }
+}

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

@@ -0,0 +1,56 @@
+import {Expression} from "../internals";
+import {ExpressionFactor} from "../internals";
+
+export class ExpFactorConstant extends ExpressionFactor {
+    private _constant: string
+    private _availableConstant: { [Key: string]:{value: number, tex: string} }
+    constructor(value: string, power?: number, root?: number) {
+        if (typeof value !== "string") {
+            throw `The number ${value} is not a valid value.`
+        }
+
+        super(null, power, root);
+
+        this._availableConstant = {
+            'pi': {
+                value: Math.PI,
+                tex: '\\pi'
+            },
+            'e': {
+                value: Math.E,
+                tex: '\\text{e}'
+            },
+            'phi': {
+                value: (1+ Math.sqrt(5))/2,
+                tex: '\\phi'
+            }
+        }
+
+        this._constant = value
+    }
+
+    get value():number {
+        // TODO: constant value
+        return Math.pow(0, this.root/this.root)
+    }
+
+    get constant(): string {
+        return this._constant
+    }
+    makeTeX(): string {
+        let tex = this._availableConstant[this._constant].tex
+        return this.texPower(this.texRoot(tex))
+    }
+
+    derivative(variable: string): Expression {
+        return undefined;
+    }
+
+    integrate(variable: string): Expression {
+        return undefined;
+    }
+
+    hasVariable(variable?: string): boolean {
+        return false
+    }
+}

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

@@ -0,0 +1,19 @@
+import {Expression} from "../internals";
+import {ExpressionFactor} from "../internals";
+
+export class ExpFactorExponential extends ExpressionFactor {
+
+    derivative(variable: string): Expression {
+        return undefined
+    }
+
+    integrate(variable: string): Expression {
+        return undefined
+    }
+
+    makeTeX(): string {
+        let tex: string = `\\text{e}^{ ${ this.argument.tex } }`
+
+        return this.texPowerAndRoot(tex)
+    }
+}

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

@@ -0,0 +1,44 @@
+import {Expression} from "../internals";
+import {ExpressionFactor} from "../internals";
+
+export class ExpFactorNumber extends ExpressionFactor {
+    private _number: number
+    constructor(value: number, power?: number, root?: number) {
+        super(null, power, root);
+
+        if (typeof value !== "number") {
+            throw `The number ${value} is not a valid value.`
+        }
+
+        this._number = value
+    }
+
+    get value():number {
+        return Math.pow(this._number, this.root/this.root)
+    }
+
+    get number(): number {
+        return this._number
+    }
+
+
+    set number(value: number) {
+        this._number = value;
+    }
+
+    makeTeX(): string {
+        return this.texPower(this.texRoot(this._number.toString()))
+    }
+
+    derivative(variable: string): Expression {
+        return undefined;
+    }
+
+    integrate(variable: string): Expression {
+        return undefined;
+    }
+
+    hasVariable(variable?: string): boolean {
+        return false
+    }
+}

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

@@ -0,0 +1,24 @@
+import {Expression} from "../internals";
+import {ExpressionFactor} from "../internals";
+
+export class ExpFactorPower extends ExpressionFactor {
+private powerArgument: Expression
+    constructor(radical: Expression, power: Expression, power2?: number, root?:number) {
+        super(radical, power2, root);
+
+        this.powerArgument = power
+    }
+    derivative(variable: string): Expression {
+        return undefined
+    }
+
+    integrate(variable: string): Expression {
+        return undefined
+    }
+
+    makeTeX(): string {
+        let tex: string = `{ ${ this.argument.tex } }^{ ${this.powerArgument.tex } }`
+
+        return this.texPowerAndRoot(this.wrapWithParentheses(tex))
+    }
+}

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

@@ -0,0 +1,44 @@
+import {Expression} from "../internals";
+import {ExpressionFactor} from "../internals";
+
+export enum TRIGONOMETRIC {
+    sin='sin',
+    cos='cos',
+    tan='tan',
+    cot='cot',
+    asin='asin',
+    atan='atan',
+    acos='acos',
+    acot='acot'
+}
+export class ExpFactorTrigo extends ExpressionFactor {
+
+    private _trigo: string
+    constructor(trigo: string, argument: Expression, power?: number, root?: number) {
+
+        super(argument, power, root);
+
+        if(! (trigo in TRIGONOMETRIC)){
+            throw `The ${ trigo } is not a valid trigonometric function.`
+        }
+
+        this._trigo = trigo
+    }
+    derivative(variable: string): Expression {
+        return undefined
+    }
+
+    integrate(variable: string): Expression {
+        return undefined
+    }
+
+    makeTeX(): string {
+        let tex = `\\${this._trigo}`
+        if(this.root>1){
+            tex += `^{ ${this.root} }`
+        }
+
+        tex+= `\\left( ${this.argument.tex} \\right)`
+        return this.texRoot(tex);
+    }
+}

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

@@ -0,0 +1,40 @@
+import {Expression} from "../internals";
+import {ExpressionFactor} from "../internals";
+
+export class ExpFactorVariable extends ExpressionFactor {
+    private _variable: string
+    constructor(value: string, power?: number, root?: number) {
+        super(null, power, root);
+
+        if (typeof value !== "string") {
+            throw `The variable ${value} is not a valid value.`
+        }
+
+        this._variable = value
+    }
+
+
+    get variable(): string {
+        return this._variable;
+    }
+
+    set variable(value: string) {
+        this._variable = value;
+    }
+
+    makeTeX(): string {
+        return this.texPower(this.texRoot(this._variable))
+    }
+
+    derivative(variable: string): Expression {
+        return undefined;
+    }
+
+    integrate(variable: string): Expression {
+        return undefined;
+    }
+
+    hasVariable(variable?: string): boolean {
+        return this._variable === variable
+    }
+}

package/src/maths/expressions/internals.ts

@@ -0,0 +1,14 @@
+export * from "./expression"
+export * from "./expressionParser"
+export * from "./expressionMember"
+
+export * from "./expressionFactor"
+export * from "./factors/ExpFactor"
+export * from "./factors/ExpFactorConstant"
+export * from "./factors/ExpFactorExponential"
+export * from "./factors/ExpFactorNumber"
+export * from "./factors/ExpFactorPower"
+export * from "./factors/ExpFactorTrigo"
+export * from "./factors/ExpFactorVariable"
+
+export * from "../shutingyard"