pimath 0.0.120 → 0.0.121

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

@@ -1,72 +0,0 @@
-import {Expression, 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()))
-    }
-
-    makeDisplay(numberOfFactors?: number, position?: number): string {
-        return this.displayPower(this.displayRoot(this._number.toString()))
-    }
-
-    derivative(variable: string): Expression {
-        return undefined;
-    }
-
-    integrate(variable: string): Expression {
-        return undefined;
-    }
-
-    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

@@ -1,42 +0,0 @@
-import {Expression} from "../internals";
-import {ExpressionFactor} from "../internals";
-
-export class ExpFactorPower extends ExpressionFactor {
-    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
-    }
-    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))
-    }
-
-    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

@@ -1,53 +0,0 @@
-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);
-    }
-
-    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

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

@@ -1,14 +0,0 @@
-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"

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

@@ -1,221 +0,0 @@
-import {Polynom} from "../algebra/polynom";
-import {Fraction} from "../coefficients/fraction";
-
-type Factor = {
-    polynom: Polynom,
-    degree: Fraction
-}
-
-export function isFactor(value: any): value is Factor {
-    return value && 'polynom' in value && 'degree' in value
-}
-
-export class PolynomExpFactor {
-    constructor(...values: unknown[]) {
-        this._powerAsInteger = true
-        this._factors = []
-
-        for (let factor of values) {
-            if (isFactor(factor)) {
-                this.addFactor({
-                    polynom: factor.polynom,
-                    degree: factor.degree
-                })
-            }
-        }
-    }
-
-    private _factors: Factor[]
-
-    get factors(): Factor[] {
-        return this._factors;
-    }
-
-    private _powerAsInteger: boolean
-
-    get powerAsInteger(): boolean {
-        return this._powerAsInteger;
-    }
-
-    set powerAsInteger(value: boolean) {
-        this._powerAsInteger = value;
-    }
-
-    get tex(): string {
-        // group positive and negative degrees.
-        const numerators: String[] = [],
-            denominators: String[] = []
-
-        for (const k of this._factors) {
-            if (k.degree.isPositive()) {
-                numerators.push(this._factorAsTex(k))
-            } else {
-                denominators.push(this._factorAsTex({
-                    polynom: k.polynom,
-                    degree: k.degree.clone().opposed()
-                }))
-            }
-        }
-
-        if (denominators.length > 0) {
-            return `\\frac{ ${numerators.length > 0 ? numerators.join('') : 1} }{ ${denominators.join('')} }`
-        } else {
-            return numerators.join('')
-        }
-    }
-
-    addFactor = (value: Factor): PolynomExpFactor => {
-        this._factors.push({
-            polynom: new Polynom(value.polynom),
-            degree: new Fraction(value.degree)
-        })
-
-        return this
-    }
-
-    multiply = (value: PolynomExpFactor): PolynomExpFactor => {
-        for (const k of value.factors) {
-            this.addFactor(k)
-        }
-        return this
-    }
-
-    divide = (value: PolynomExpFactor): PolynomExpFactor => {
-        for (const k of value.factors) {
-            this.addFactor({
-                polynom: k.polynom,
-                degree: k.degree.clone().opposed()
-            })
-        }
-        return this
-    }
-
-    derivative = (letter: string): PolynomExp => {
-        // A*B*C*D =
-
-        // Basic version
-        // TODO: create derivative with more than only two factors.
-        if (this._factors.length === 2) {
-            const A = this._factors[0], B = this._factors[1],
-                P = new PolynomExp()
-            let Ad = this._factorDerivative(A),
-                Bd = this._factorDerivative(B)
-
-            P.add(
-                new PolynomExpFactor(
-                    {
-                        polynom: A.polynom.derivative(letter),
-                    }
-                )
-            )
-        }
-        return
-    }
-
-    private _factorDerivative = (factor: Factor, letter?: string): PolynomExpFactor => {
-        let derivativeExpression = new PolynomExpFactor()
-        derivativeExpression.addFactor({polynom: new Polynom(factor.degree), degree: new Fraction().one()})
-        derivativeExpression.addFactor({polynom: factor.polynom, degree: factor.degree.subtract(1)})
-        derivativeExpression.addFactor({
-            polynom: factor.polynom.clone().derivative(letter),
-            degree: new Fraction().one()
-        })
-
-        return derivativeExpression
-
-    }
-
-    private _factorAsTex = (factor: Factor, withParenthesis?: Boolean): string => {
-        let tex: string = ''
-
-        if (factor.degree.isOne()) {
-            if (withParenthesis === undefined || withParenthesis) {
-                tex = `\\left(${factor.polynom.tex}\\right)`
-            } else {
-                tex = factor.polynom.tex
-            }
-        } else if (factor.degree.isNatural()) {
-            tex = `\\left(${factor.polynom.tex}\\right)^{ ${factor.degree.tex} }`
-        } else {
-            if (this._powerAsInteger) {
-                if (factor.degree.denominator === 2) {
-                    tex = `\\sqrt{${factor.polynom.tex}}`
-                } else {
-                    tex = `\\sqrt[${factor.degree.denominator}]{${factor.polynom.tex}}`
-                }
-
-                if (factor.degree.numerator !== 1) {
-                    tex += `^{ ${factor.degree.numerator} }`
-                }
-            } else {
-                tex = `\\left(${factor.polynom.tex}\\right)^{ ${factor.degree.tex} }`
-            }
-        }
-        return tex
-    }
-}
-
-export class PolynomExp {
-    private _factors: { factors: PolynomExpFactor, positive: boolean }[]
-
-    constructor(...values: PolynomExpFactor[]) {
-        this._factors = []
-        if (values !== undefined) {
-            for (const factor of values) {
-                this._factors.push({
-                    factors: factor,
-                    positive: true
-                })
-            }
-        }
-        this._powerAsInteger = true
-    }
-
-    private _powerAsInteger: boolean
-
-    get powerAsInteger(): boolean {
-        return this._powerAsInteger;
-    }
-
-    set powerAsInteger(value: boolean) {
-        for (const factor of this._factors) {
-            factor.factors.powerAsInteger = value
-        }
-        this._powerAsInteger = value;
-    }
-
-    get tex(): string {
-        let tex = ''
-
-        for (const factor of this._factors) {
-            if (factor.factors.tex === '') {
-                continue
-            }
-            if (tex !== '' || !factor.positive) {
-                tex += factor.positive ? '+' : '-'
-            }
-            tex += factor.factors.tex
-        }
-
-
-        return tex
-    }
-
-    add = (value: PolynomExpFactor): PolynomExp => {
-        value.powerAsInteger = this._powerAsInteger
-        this._factors.push({
-            factors: value,
-            positive: true
-        })
-        return this
-    }
-
-    subtract = (value: PolynomExpFactor): PolynomExp => {
-        value.powerAsInteger = this._powerAsInteger
-        this._factors.push({
-            factors: value,
-            positive: false
-        })
-        return this
-    }
-}