pimath 0.0.120 → 0.0.122

package/src/maths/expressions/expressionMember.ts

@@ -1,233 +0,0 @@
-import {ExpFactorNumber, ExpFactorVariable, ExpressionFactor} from "./internals";
-
-export class ExpressionMember {
-    private _factors: ExpressionFactor[]
-
-    constructor(...values: ExpressionFactor[]) {
-        this._factors = values
-    }
-
-    get factors(): ExpressionFactor[] {
-        return this._factors;
-    }
-
-    set factors(value: ExpressionFactor[]) {
-        this._factors = value;
-    }
-
-    get numerator(): ExpressionFactor[] {
-        return this._factors.filter(factor => factor.power > 0)
-    }
-
-    get denominator(): ExpressionFactor[] {
-        return this._factors.filter(factor => factor.power < 0)
-    }
-
-    get tex(): string {
-        return this.toString(true)
-    }
-
-    get display(): string {
-        return this.toString(false)
-    }
-
-    toString(asTex: boolean): string {
-        if (asTex === undefined) {
-            asTex = true
-        }
-
-        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 {
-                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 " : "*"
-                            }
-
-                        }
-                    }
-                }
-            }
-        }
-
-        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
-    }
-
-    addFactors(...values: ExpressionFactor[]): ExpressionMember {
-
-        for (let value of values) {
-            this._factors.push(value)
-        }
-
-        return this
-    }
-
-    isZero(): Boolean {
-
-        if (this._factors.length === 0) {
-            return true
-        }
-
-        for (let factor of this._factors) {
-            if (factor.isZero()) {
-                return true
-            }
-        }
-
-        return false
-    }
-
-    hasVariable(variable?: string): boolean {
-
-        if (variable === undefined) {
-            return !this.isNumeric()
-        }
-
-
-        for (let factor of this._factors) {
-            if (factor.hasVariable(variable)) {
-                return true
-            }
-        }
-
-        return false
-    }
-
-    isNumeric(): boolean {
-        for (let factor of this._factors) {
-            if (factor instanceof ExpFactorVariable) {
-                return false
-            }
-        }
-
-        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/expressionOperators.ts

@@ -1,49 +0,0 @@
-import {Expression} from "./expression";
-import {ExpFactor} from "./factors/ExpFactor";
-import {ExpressionMember} from "./expressionMember";
-
-export class expressionOperators {
-    static reduce(expr:Expression):Expression {
-        let output = new Expression()
-
-        return null
-    }
-
-    static add(...values: Expression[]): Expression {
-        let output = new Expression()
-        for(let expr of values){
-            output.addMembers(...expr.members)
-        }
-        return output
-    }
-
-    static subtract(a: Expression, b: Expression): Expression{
-        let output = new Expression()
-        output.add(a)
-        output.subtract(b)
-        return output
-    }
-
-    static multiply(...values: Expression[]): Expression{
-        let output = new Expression(),
-            member = new ExpressionMember()
-
-        for(let expr of values){
-            member.add(new ExpFactor(expr))
-        }
-
-        return output.add(member)
-    }
-
-    static divide(a: Expression, b: Expression): Expression{
-        let output = new Expression(),
-            member = new ExpressionMember()
-
-        // Add the first element as factor
-        member.add(new ExpFactor(a))
-        // Divide by the second element.
-        member.add(new ExpFactor(b, -1))
-
-        return output.add(member)
-    }
-}

package/src/maths/expressions/expressionParser.ts

@@ -1,295 +0,0 @@
-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') {
-                        stack.push(this.tokenOperationSqrt(a))
-                    } else if (item.token === 'nthrt') {
-                        stack.push(this.tokenOperationRoot(a, stack.pop()))
-                    } 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 {
-        let EM = new ExpressionMember()
-        if (a instanceof Expression) {
-            EM.addFactors(new ExpFactor(a))
-            // a = new ExpFactor(a)
-        } else if (a instanceof ExpressionMember) {
-            // 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)
-            EM.addFactors(new ExpFactor(b))
-        } else if (b instanceof ExpressionMember) {
-            // b = new ExpFactor(new Expression(b))
-            EM.addFactors(...b.factors)
-        } else if (b instanceof ExpressionFactor) {
-            // Do nothing
-            EM.addFactors(b)
-        }
-
-        return EM
-    }
-
-    private tokenOperationDivide(a: Expression | ExpressionMember | ExpressionFactor, b: Expression | ExpressionMember | ExpressionFactor): ExpressionMember {
-        let EM = new ExpressionMember()
-
-        if (a instanceof Expression) {
-            EM.addFactors(new ExpFactor(a))
-        } else if (a instanceof ExpressionMember) {
-            EM.addFactors(...a.factors)
-        } else if (a instanceof ExpressionFactor) {
-            // Do nothing
-            EM.addFactors(a)
-        }
-
-        if (b instanceof Expression) {
-            EM.addFactors(new ExpFactor(b, -1))
-        } else if (b instanceof ExpressionMember) {
-            EM.addFactors(new ExpFactor(new Expression(b), -1))
-        } else if (b instanceof ExpressionFactor) {
-            // Do nothing
-            b.power = -b.power
-            EM.addFactors(b)
-        }
-
-        return EM
-    }
-
-    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
-            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 :
-        // 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)
-
-    }
-
-    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,39 +0,0 @@
-import {Expression, 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 {
-        // TODO: no need to wrap if it's single ?
-        if (this.hasRoot() || this.hasPower()) {
-            return this.texPower(this.texRoot(
-                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

@@ -1,60 +0,0 @@
-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
-    }
-
-    makeDisplay(numberOfFactors?: number, position?: number): string {
-        return this._constant;
-    }
-}

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

@@ -1,26 +0,0 @@
-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)
-    }
-
-    makeDisplay(numberOfFactors?: number, position?: number): string {
-        let display: string = `e^( ${ this.argument.tex } )`
-
-        return this.displayPowerAndRoot(display)
-    }
-
-}