pimath 0.0.120 → 0.0.122

package/src/maths/expressions/ExpressionTree.ts

@@ -1,172 +0,0 @@
-import {Shutingyard, ShutingyardMode, ShutingyardType, Token} from "../shutingyard";
-
-export class ExpressionTree {
-    private _root: ExpressionNode
-    private _rpn: Token[]
-
-    constructor(value: string) {
-        this._root = this._parse(value)
-    }
-
-    get tex(): string {
-        return this._root.tex
-    }
-
-    print(): string {
-        return this._root.print(0, []).join('\n')
-    }
-
-    private _parse(value: string) {
-        let SY = new Shutingyard(ShutingyardMode.EXPRESSION).parse(value)
-
-        // Store the rpn
-        this._rpn = SY.rpn
-
-        // Build the tree with nodes.
-        let stack: ExpressionNode[] = []
-
-        for (let item of this._rpn) {
-            switch (item.tokenType) {
-                case ShutingyardType.COEFFICIENT:
-                    stack.push(new ExpressionNode(item.tokenType, item.token))
-                    break
-                case ShutingyardType.CONSTANT:
-                    stack.push(new ExpressionNode(item.tokenType, item.token))
-                    break
-                case ShutingyardType.VARIABLE:
-                    stack.push(new ExpressionNode(item.tokenType, item.token))
-                    break
-                case ShutingyardType.OPERATION:
-                    if (stack.length >= 2) {
-                        let b = stack.pop(),
-                            a = stack.pop()
-
-                        stack.push(new ExpressionNode(item.token, a, b))
-                    }
-                    break
-                case ShutingyardType.FUNCTION:
-                    let a = stack.pop()
-
-                    switch (item.token) {
-                        case 'nthrt':
-                            stack.push(new ExpressionNode(item.token, a, stack.pop()))
-                            break
-                        default:
-                            stack.push(new ExpressionNode(item.token, a))
-                    }
-
-                    break
-                default:
-                    throw(`Something went wrong while parsing ${value} at ${item.token}`)
-            }
-        }
-
-        return stack[0]
-    }
-}
-
-const operationFunction: string[] = ['nthrt']
-const softwrap: string[] = ['*', '^', 'sqrt', 'nthrt']
-function TeXit(value: ExpressionNode | string, parentheses?:boolean, soft?:boolean): string {
-    if (value === undefined) {
-        return ''
-    }
-    if (value === null) {
-        return ''
-    }
-
-    let addParentheses = parentheses===true
-    if(addParentheses){
-        if(soft===true){
-            if(value instanceof ExpressionNode){
-                if(value.isSingle()){
-                    addParentheses = false
-                }
-                // The current element might not need to be wrapped.
-                if(softwrap.includes(value.op)){
-                    addParentheses = false
-                }
-            }else{
-                addParentheses = false
-            }
-        }
-    }
-
-    if (value instanceof ExpressionNode) {
-        return addParentheses===true?`\\left( ${ value.tex } \\right) `:value.tex
-    } else {
-        return value
-    }
-}
-
-export class ExpressionNode {
-    private _children: (ExpressionNode | string)[]
-    private _op: string
-
-    constructor(op: string, ...children: (ExpressionNode | string)[]) {
-        this._op = op
-        this._children = children
-    }
-
-    get op(): string {
-        return this._op;
-    }
-
-    get tex(): string {
-        let a = this._children[0],
-            b = this._children[1]
-
-        switch (this._op) {
-            case ShutingyardType.COEFFICIENT:
-            case ShutingyardType.CONSTANT:
-            case ShutingyardType.VARIABLE:
-                if (typeof a === "string") {
-                    return a
-                } else {
-                    return ''
-                }
-            case '+':
-                return `${TeXit(a)} ${this._op} ${TeXit(b)}`
-            case'-':
-                return `${TeXit(a)} ${this._op} ${TeXit(b, true, true)}`
-            case '*':
-                return `${TeXit(a, true, true)} \\cdot ${TeXit(b, true, true)}`
-            case '/':
-                return `\\frac{ ${TeXit(a)} }{ ${TeXit(b)} }`
-            case '^':
-                return `${TeXit(a, true)}^{ ${TeXit(b)} }`
-            case 'sqrt':
-                return `\\sqrt{ ${TeXit(a)} }`
-            default:
-                throw(`Something went wrong with ${this._op}`)
-        }
-    }
-
-    isSingle() {
-        return this._op === ShutingyardType.COEFFICIENT ||
-            this._op === ShutingyardType.VARIABLE ||
-            this._op === ShutingyardType.CONSTANT
-    }
-
-    print(tab: number, stack: string[]): string[] {
-        // Tabulation
-        let tabChr = ''
-        for (let i = 0; i < tab; i++) {
-            tabChr += '\t'
-        }
-
-        // Walk through all nodes.
-        let row: string[] = [`${tabChr}${this._op}`]
-
-        for (let child of this._children) {
-            if (child instanceof ExpressionNode) {
-                row = [...child.print(tab + 1, row)]
-            } else {
-                row[row.length - 1] += ` -> ${child}`
-            }
-
-        }
-
-        return [...stack, ...row]
-    }
-}

package/src/maths/expressions/expression.ts

@@ -1,286 +0,0 @@
-import {
-    ExpFactor,
-    ExpFactorConstant,
-    ExpFactorNumber, ExpFactorPower,
-    ExpFactorVariable,
-    ExpressionFactor,
-    ExpressionMember
-} from "./internals";
-
-export type ExpressionMemberType = { member: ExpressionMember, sign: number }
-
-export class Expression {
-    private _members: ExpressionMemberType[]
-
-    constructor(...values: (ExpressionMember | ExpressionFactor | ExpressionMemberType)[]) {
-        this._members = []
-        this.addMembers(...values)
-        return this
-    }
-
-    get tex(): string {
-        let tex: string = ""
-        for (let item of this._members) {
-
-            try {
-                if (tex === "") {
-                    tex = (item.sign === -1 ? "-" : "") + item.member.tex
-                } else {
-                    tex += (item.sign === -1 ? "-" : "+") + item.member.tex
-                }
-            } catch {
-                console.log('Error while generating the TeX code for ', item.constructor.name)
-            }
-        }
-        return tex
-    }
-
-    get display(): string {
-        let display: string = ""
-        for (let item of this._members) {
-
-            try {
-                if (display === "") {
-                    display = (item.sign === -1 ? "-" : "") + item.member.display
-                } else {
-                    display += (item.sign === -1 ? "-" : "+") + item.member.display
-                }
-            } catch {
-                console.log('Error while generating the display code for ', item.constructor.name)
-            }
-        }
-        return display
-    }
-
-    get members(): ExpressionMemberType[] {
-        return this._members;
-    }
-
-    set members(value: ExpressionMemberType[]) {
-        this._members = value;
-    }
-
-    addMembers(...values: (ExpressionMemberType | ExpressionMember | ExpressionFactor)[]): Expression {
-        for (let item of values) {
-            if (item instanceof ExpressionMember) {
-                this._members.push({
-                    member: item,
-                    sign: 1
-                })
-            } else if (item instanceof ExpressionFactor) {
-                this._members.push({
-                    member: new ExpressionMember(item),
-                    sign: 1
-                })
-            } else {
-                this._members.push(item)
-            }
-        }
-
-        return this
-    }
-
-    add(value: Expression | ExpressionMember | ExpressionFactor) {
-        if (value instanceof Expression) {
-            this.members = this.members.concat(...value.members)
-        } else if (value instanceof ExpressionMember) {
-            this.members.push({
-                    member: value,
-                    sign: 1
-                }
-            )
-        } else if (value instanceof ExpressionFactor) {
-            this.members.push({
-                member: new ExpressionMember(value),
-                sign: 1
-            })
-        }
-
-        return this
-    }
-
-    subtract(value: Expression | ExpressionMember | ExpressionFactor) {
-
-        if (value instanceof Expression) {
-            this.members = this.members.concat(
-                ...value.members
-                    .map(item => {
-                            return {member: item.member, sign: -item.sign}
-                        }
-                    )
-            )
-        } else if (value instanceof ExpressionMember) {
-            this.members.push({
-                    member: value,
-                    sign: -1
-                }
-            )
-        } else if (value instanceof ExpressionFactor) {
-            this.members.push({
-                member: new ExpressionMember(value),
-                sign: -1
-            })
-        }
-
-        return this
-    }
-
-    variables(): string[] {
-        let values: string[] = [],
-            varFactor: ExpFactorVariable[]
-
-
-        values = this.getAllFactors().filter(x => x instanceof ExpFactorVariable).map(x => {
-            return x instanceof ExpFactorVariable ? x.variable : null
-        })
-
-        return [...new Set(values)]
-    }
-
-    isPolynom(): Boolean {
-        // Allow variable, number, factor, power, constant
-        let factors = this.getAllFactors()
-
-        for (let factor of factors) {
-            // No root
-            if (factor.root > 1) {
-                return false
-            }
-
-            // Allow power, as long as the power argument is numeric
-            if(factor instanceof ExpFactorPower){
-                if(!factor.powerArgument.isNumeric()){return false}
-                // TODO: the power must be an integer value.
-
-                if(!factor.powerArgument.isNumber()){return false}
-            }
-
-            // Allow some type of factors.
-            if (!(
-                factor instanceof ExpFactor ||
-                factor instanceof ExpFactorConstant ||
-                factor instanceof ExpFactorNumber ||
-                factor instanceof ExpFactorVariable
-            )) {
-                return false
-            }
-        }
-
-        return true
-    }
-
-    getAllFactors(): ExpressionFactor[] {
-        let EF: ExpressionFactor[] = []
-
-        for (let item of this._members) {
-            for (let factor of item.member.factors) {
-                EF.push(factor)
-                for(let expr of factor.getArguments()){
-                    EF = EF.concat(...expr.getAllFactors())
-                }
-            }
-        }
-
-        return EF
-    }
-
-    hasVariable(variable?: string): boolean {
-
-        if (variable === undefined) {
-            return !this.isNumeric()
-        }
-
-
-        for (let item of this._members) {
-            if (item.member.hasVariable(variable)) {
-                return true
-            }
-        }
-
-        // The variable hasn't been found !
-        return false
-    }
-
-    isZero(): boolean {
-        // TODO: Must check if all the members has a value of zero
-        if (this._members.length === 0) {
-            return true
-        }
-
-        for (let item of this._members) {
-            if (item.member.isZero()) {
-                return true
-            }
-        }
-
-        return false
-    }
-
-    isNumeric(): boolean {
-        for (let item of this._members) {
-            if (!item.member.isNumeric()) {
-                return false
-            }
-        }
-        return true;
-    }
-
-    isNumber(): boolean {
-        if(this._members.length===1) {
-            if (this._members[0]?.member.factors[0] instanceof ExpFactorNumber) {
-                return this._members[0].member.factors[0].root === 1
-            }
-        }
-
-        return false
-    }
-
-    isSingle(): Boolean {
-        if (this.members.length > 1) {
-            return false
-        } else if (this.members[0]?.member.factors.length > 1) {
-            return false
-        } else {
-            return true
-        }
-
-    }
-
-    isFactor(): Boolean {
-        return this.members.length === 1
-    }
-
-
-    structure(depth?: number): string {
-        let struct: string[] = [],
-            indent = "",
-            dftIndent = "\t"
-
-        if (depth === undefined) {
-            depth = 0
-        }
-        for (let i = 0; i < depth; i++) {
-            indent += dftIndent
-        }
-
-        struct.push(`${indent}${this.constructor.name}: ${this.tex}`)
-        for (let item of this._members) {
-            struct.push(`${indent}${dftIndent}${item.member.constructor.name}: ${item.member.tex}`)
-            for (let factor of item.member.factors) {
-                struct.push(`${indent}${dftIndent}${dftIndent}${factor.constructor.name}: ${factor.tex} ; power: ${factor.power}; root: ${factor.root}`)
-                if (factor.argument !== null) {
-                    struct.push(factor.argument.structure(depth + 3))
-                }
-            }
-        }
-        return struct.join('\n')
-    }
-
-    reduce():Expression {
-        for(let item of this.members){
-            item.member.reduce()
-        }
-        return this
-    }
-}
-

package/src/maths/expressions/expressionFactor.ts

@@ -1,190 +0,0 @@
-import {Expression} from "./internals";
-import {Numeric} from "../numeric";
-
-export abstract class ExpressionFactor {
-    constructor(
-        private _argument: Expression,
-        private _power?: number,
-        private _root?: number,
-        private _inline?: boolean
-    ) {
-        if (this._power === undefined) {
-            this._power = 1
-        }
-        if (this._root === undefined) {
-            this._root = 1
-        }
-        if (this._inline === undefined) {
-            this._inline = false
-        }
-    }
-
-    get inline(): boolean {
-        return this._inline;
-    }
-
-    set inline(value: boolean) {
-        this._inline = value;
-    }
-
-    get tex(): string {
-        return this.makeTeX()
-    }
-
-    get display(): string {
-        return this.makeDisplay()
-    }
-
-    get power(): number {
-        return this._power;
-    }
-
-    set power(value: number) {
-        if (!Number.isSafeInteger(value)) {
-            throw `Power value (${value}) is not a safe integer`
-        }
-        this._power = value;
-    }
-
-    get root(): number {
-        return this._root;
-    }
-
-    set root(value: number) {
-        if (!Number.isSafeInteger(value)) {
-            throw `Root value (${value}) is not a safe integer`
-        }
-        this._root = value;
-    }
-
-    get argument(): Expression {
-        return this._argument;
-    }
-
-    set argument(value: Expression) {
-        this._argument = value;
-    }
-
-    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) {
-            return !this.isNumeric()
-        }
-
-        // The argument is an Expression
-        if (this._argument instanceof Expression) {
-            return this._argument.hasVariable(variable)
-        }
-
-        return false
-    }
-
-    isNumeric(): boolean {
-        for(let expressionArgument of this.getArguments()){
-            if(!expressionArgument.isNumeric()){return false}
-        }
-        return true
-    }
-
-    hasRoot(): boolean {
-        return this.root > 1
-    }
-
-    hasPower(inline?: boolean): boolean {
-        if (inline === true) {
-            return !(this.power === 1)
-        } else {
-            return !(this.power === 1 || this.power === -1)
-        }
-    }
-
-
-    texPowerAndRoot(tex: string): string {
-        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)} }`
-        }
-
-        return tex
-    }
-
-    wrapWithParentheses(tex: string, asTex?: boolean): string {
-        if(asTex===undefined || asTex===true) {
-            return `\\left( ${tex} \\right)`
-        }else{
-            return `( ${tex} )`
-        }
-    }
-
-    texRoot(tex: string): string {
-        if (this.root === 2) {
-            return `\\sqrt{ ${tex} }`
-        } else if (this.root > 2) {
-            return `\\sqrt[${this.root}]{ ${tex} }`
-        }
-
-        return tex
-    }
-
-    isZero(): Boolean {
-        if (this._argument instanceof Expression) {
-            return this._argument.isZero()
-        }
-
-        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
-    }
-}