pimath 0.0.28 → 0.0.32

package/src/maths/coefficients/fraction.ts

@@ -1,5 +1,6 @@
 import {Numeric} from "../numeric";
 
+export type FractionParsingType = number|string|Fraction
 /**
  * The fraction class make possible to handle
  * TODO: Write the documentation correctly.
@@ -75,6 +76,9 @@ export class Fraction {
     get dfrac(): string {
         return this.tex.replace('\\frac', '\\dfrac');
     }
+    get tfrac(): string {
+        return this.tex.replace('\\frac', '\\tfrac')
+    }
 
     // ------------------------------------------
     // Creation / parsing functions
@@ -147,6 +151,7 @@ export class Fraction {
                         this._numerator = value * Math.pow(10, p) - Math.floor(value * Math.pow(10, p - denominatorOrPeriodic));
                         this.denominator = Math.pow(10, p) - Math.pow(10, p - denominatorOrPeriodic)
                     }
+                    this.reduce()
                 }
                 break;
             case "object":
@@ -255,23 +260,32 @@ export class Fraction {
         return this;
     }
     pow = (p: number | Fraction): Fraction => {
-        // TODO: Fraction.pow with a value different than a safe integer ?
+        // TODO: Fraction.pow with a value different than a safe integer !
         if (p instanceof Fraction) {
             return this.pow(p.value)
         }
 
-        if (!Number.isSafeInteger(p)) {
-            return this.invalid();
-        }
-
         this.reduce();
-
         if (p < 0) {
             this.invert()
         }
 
-        this._numerator = this._numerator ** Math.abs(p);
-        this._denominator = this._denominator ** Math.abs(p);
+        // Check if numerator and denominator are roots of...
+        // othervise, convert to numeric.
+        let controlNumerator = Math.floor(Math.pow(this._numerator, Math.abs(p))),
+            controlDenominator = Math.floor(Math.pow(this._denominator, Math.abs(p)))
+
+        if(controlNumerator ** Math.abs(p) === this._numerator
+            &&
+            controlDenominator ** Math.abs(p) === this._denominator){
+
+            this._numerator = this._numerator ** Math.abs(p);
+            this._denominator = this._denominator ** Math.abs(p);
+        }else{
+            this._numerator = this._numerator ** Math.abs(p);
+            this._denominator = this._denominator ** Math.abs(p);
+        }
+
         return this;
     };
 
@@ -461,16 +475,19 @@ export class Fraction {
         return Math.abs(Numeric.gcd(this._numerator, this._denominator)) === 1
     }
     isNatural = (): boolean => {
+        return this.isRelative() && this.isPositive()
+    }
+    isRelative = (): boolean => {
         return this.clone().reduce().denominator === 1
     }
     isRational = (): boolean => {
-        return !this.isNatural()
+        return !this.isRelative()
     }
     isEven = (): boolean => {
-        return this.isNatural() && this.value % 2 === 0
+        return this.isRelative() && this.value % 2 === 0
     }
     isOdd = (): boolean => {
-        return this.isNatural() && this.value % 2 === 1
+        return this.isRelative() && this.value % 2 === 1
     }
     sign = (): number => {
         return (this._numerator * this._denominator >= 0) ? 1 : -1;

package/src/maths/{numexp.ts → expressions/numexp.ts}

@@ -1,9 +1,10 @@
-import {Shutingyard, ShutingyardMode, ShutingyardType, tokenConstant} from "./shutingyard";
-import {Fraction} from "./coefficients";
+import {Shutingyard, ShutingyardMode, ShutingyardType, tokenConstant} from "../shutingyard";
+import {Fraction} from "../coefficients";
 
 export class NumExp {
     private _rpn: { token: string, tokenType: string }[]
     private _expression: string
+    private _isValid: boolean
 
     constructor(value: string) {
         this._expression = value
@@ -14,6 +15,17 @@ export class NumExp {
         return this._rpn;
     }
 
+    get isValid(): boolean {
+        if(this._isValid===undefined){
+            this.evaluate({x: 0})
+        }
+        return this._isValid
+    }
+
+    set isValid(value: boolean){
+        this._isValid = value
+    }
+
     get expression(): string {
         return this._expression;
     }
@@ -41,7 +53,7 @@ export class NumExp {
         const epsilon = 0.00000000000001,
             number_of_digits = 6
 
-        let decimal = this._extractDecimalPart(value)
+        const decimal = this._extractDecimalPart(value)
         if(decimal===''){return value}
 
         const n9 = decimal.match(/9+$/g)
@@ -49,7 +61,7 @@ export class NumExp {
 
         if (n9 && n9[0].length >= number_of_digits) {
             // New tested values.
-            let mod = this._extractDecimalPart(value + epsilon),
+            const mod = this._extractDecimalPart(value + epsilon),
                 mod0 = mod.match(/0+$/g)
 
             if(mod0 && mod0[0].length>= number_of_digits){
@@ -60,7 +72,7 @@ export class NumExp {
 
         if (n0 && n0[0].length >= number_of_digits) {
             // New tested values.
-            let mod = this._extractDecimalPart(value - epsilon),
+            const mod = this._extractDecimalPart(value - epsilon),
                 mod9 = mod.match(/9+$/g)
 
             if(mod9 && mod9[0].length>= number_of_digits){
@@ -77,7 +89,10 @@ export class NumExp {
     }
 
     evaluate(values: { [Key: string]: number }): number {
-        let stack: number[] = []
+        const stack: number[] = []
+
+        this.isValid = true
+
         for (const element of this._rpn) {
             if (element.tokenType === ShutingyardType.COEFFICIENT) {
                 // May be a numeric value or a Fraction.
@@ -94,34 +109,42 @@ export class NumExp {
                 this._addToStack(stack, tokenConstant[element.token])
             } else if (element.tokenType === ShutingyardType.OPERATION) {
                 if (element.token === '*') {
-                    const b = +stack.pop(),
-                        a = +stack.pop()
+                    const b = stack.pop(),
+                        a = stack.pop()
+                    if(a === undefined || b === undefined){this.isValid = false}
                     this._addToStack(stack, a * b)
                 } else if (element.token === '/') {
-                    const b = +stack.pop(),
-                        a = +stack.pop()
+                    const b = stack.pop(),
+                        a = stack.pop()
+                    if(a === undefined || b === undefined){this.isValid = false}
                     this._addToStack(stack, a / b)
                 } else if (element.token === '+') {
-                    const b = +stack.pop(),
-                        a = +stack.pop()
-                    this._addToStack(stack, a + b)
+                    const b = stack.pop(),
+                        a = stack.pop()
+                    if(a === undefined || b === undefined){this.isValid = false}
+                    this._addToStack(stack, (+a) + (+b))
                 } else if (element.token === '-') {
-                    const b = +stack.pop(),
-                        a = +stack.pop()
+                    const b = stack.pop(),
+                        a = stack.pop() || 0
+                    if(b === undefined){this.isValid = false}
                     this._addToStack(stack, a - b)
                 } else if (element.token === '^') {
-                    const b = +stack.pop(),
-                        a = +stack.pop()
+                    const b = stack.pop(),
+                        a = stack.pop()
+                    if(a === undefined || b === undefined){this.isValid = false}
                     this._addToStack(stack, Math.pow(a, b))
                 }
             } else if (element.tokenType === ShutingyardType.FUNCTION) {
-                const a = +stack.pop()
+                const a = stack.pop()
+                if(a === undefined){this.isValid = false}
                 if (element.token === 'sin') {
                     this._addToStack(stack, Math.sin(a))
                 } else if (element.token === 'cos') {
                     this._addToStack(stack, Math.cos(a))
                 } else if (element.token === 'tan') {
                     this._addToStack(stack, Math.tan(a))
+                } else if(element.token === 'sqrt') {
+                    this._addToStack(stack, Math.sqrt(a))
                 }
             }
         }
@@ -129,8 +152,7 @@ export class NumExp {
         if (stack.length === 1) {
             return stack[0]
         } else {
-            console.error('There was a problem parsing', this._expression, '. The RPN array is', this._rpn)
-            return 0
+            throw `There was a problem parsing: ${this._expression}`
         }
     }
 }

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

@@ -0,0 +1,223 @@
+import {Polynom} from "../algebra";
+import {Fraction} from "../coefficients";
+
+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()
+                }))
+            }
+        }
+
+        console.log(numerators.length)
+        if (denominators.length > 0) {
+            return `\\dfrac{ ${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) {
+                console.log('ADDING', factor.tex)
+                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
+    }
+}