pimath 0.1.39 → 0.1.40

package/src/coefficients/nthRoot.ts

@@ -0,0 +1,149 @@
+// TODO: Remove NthRoot class
+/**
+ * NthRoot is something like "a+b\sqrt{3}
+ */
+export class NthRoot {
+    #radical: number
+    #nth: number
+    #coefficient: number
+    #isValid: boolean
+
+    constructor(...values: number[]) {
+        this.#radical = 1
+        this.#coefficient = 1
+        this.#nth = 2
+        this.#isValid = true
+
+        if (values.length > 0) {
+            this.parse(values[0], values[1], values[2])
+        }
+    }
+
+    // ------------------------------------------
+    // Getter and setter
+    // ------------------------------------------
+    get radical(): number {
+        return this.#radical
+    }
+
+    set radical(value: number) {
+        this.#radical = value
+    }
+
+    get nth(): number {
+        return this.#nth
+    }
+
+    set nth(value: number) {
+        if (Number.isSafeInteger(value) && value >= 2) {
+            this.#nth = value
+        } else {
+            // Error setting the nth root.
+            console.log('Error setting the nth root')
+            this.#nth = 2
+        }
+    }
+
+    get coefficient(): number {
+        return this.#coefficient
+    }
+
+    set coefficient(value: number) {
+        this.#coefficient = value
+    }
+
+    get tex(): string {
+        let C: string
+
+        if (this.#coefficient === 1) {
+            C = ''
+        } else if (this.#coefficient === -1) {
+            C = '-'
+        } else {
+            C = this.#coefficient.toString()
+        }
+
+        if (this.#radical === 1) {
+            return `${this.#coefficient}`
+        } else {
+            if (this.#nth === 2) {
+                return `${C}\\sqrt{${this.#radical}}`
+            } else {
+                return `${C}\\sqrt[${this.#nth}]{${this.#radical}}`
+            }
+        }
+    }
+
+    get display(): string {
+        let C: string
+
+        if (this.#coefficient === 1) {
+            C = ''
+        } else if (this.#coefficient === -1) {
+            C = '-'
+        } else {
+            C = this.#coefficient.toString()
+        }
+
+        if (this.#radical === 1) {
+            return `${this.#coefficient}`
+        } else {
+            if (this.#nth === 2) {
+                return `${C}sqrt{${this.#radical}}`
+            } else {
+                return `${C}root(${this.#nth}){${this.#radical}}`
+            }
+        }
+    }
+
+    get value(): number {
+        return this.#coefficient * Math.pow(this.#radical, 1 / this.#nth)
+    }
+
+    // ------------------------------------------
+    // Creation / parsing functions
+    // ------------------------------------------
+    parse = (radical: number, nthroot?: number, coefficient?: number): this => {
+        this.#coefficient = coefficient ?? 1
+        this.#nth = nthroot ?? 2
+        this.#radical = radical
+
+        if (this.#nth % 2 === 0 && this.#radical < 0) {
+            this.#isValid = false
+        }
+        return this
+    }
+
+    // ------------------------------------------
+    // Mathematical operations
+    // ------------------------------------------
+    reduce = (): this => {
+        // Max value to test.
+        let V = Math.floor(Math.pow(this.#radical, 1 / this.#nth))
+        while (V > 1) {
+            if (this.#radical % Math.pow(V, this.#nth) === 0) {
+                // It's dividable by V^n
+                this.#coefficient *= V
+                this.#radical = this.#radical / Math.pow(V, this.#nth)
+
+                // Redifine the new testing value (this is optimization)
+                V = Math.floor(Math.pow(this.#radical, 1 / this.#nth))
+                continue
+            }
+            V--
+        }
+        return this
+    }
+
+    multiply = (N: NthRoot): this => {
+        this.#radical *= N.radical
+        return this.reduce()
+    }
+
+    // ------------------------------------------
+    // Help functions
+    // ------------------------------------------
+    hasRadical = (): boolean => {
+        return !(this.#radical === 1 || this.#radical === 0 || !this.#isValid)
+    }
+}

package/src/coefficients/root.ts

@@ -0,0 +1,299 @@
+import {Fraction} from "./fraction"
+import type {IExpression, InputValue, IPiMathObject} from "../pimath.interface"
+import {stripParenthesis} from "../helpers"
+import {Numeric} from "../numeric"
+
+export class Root implements IPiMathObject<Root>, IExpression<Root> {
+    #factor: Fraction
+    #index: number
+    #radical: Fraction
+
+    constructor(value?: InputValue<Root | Fraction>) {
+        this.#index = 2
+        this.#factor = new Fraction().one()
+        this.#radical = new Fraction().zero()
+
+        if (value) {
+            this.parse(value)
+        }
+
+
+        return this
+    }
+
+    parse(value: InputValue<Root | Fraction>): this {
+        // should be able to parse "display" roots.
+        // sqrt12 or sqrt(12) or sqrt(12/5) => [2, 12 or 12/5, 1]
+        // root(n)10 or root(n)(10) or root(n)(10/3) => [n, 10 or 10/3, 1]
+        // 7sqrt12 or 7sqrt(12) or 7sqrt(12/5) => [2, 12 or 12/5, 7]
+        // 7root(n)10 or 7root(n)(10) or 7root(n)(10/3) => [n, 10 or 10/3, 7]
+
+        if (value instanceof Root) {
+            this.index = value.index
+            this.radical = value.radical.clone()
+            this.factor = value.factor.clone()
+
+            return this
+        }
+        if (value instanceof Fraction) {
+            this.index = 2
+            this.factor = value.clone()
+            this.radical.one()
+
+            return this
+        }
+
+        if (typeof value === "string") {
+            if (value.includes('sqrt')) {
+                return this.#parse_sqrt(value)
+            }
+
+            if (value.includes('root')) {
+                return this.#parse_root(value)
+            }
+        }
+
+        this.index = 2
+        this.factor = new Fraction(value)
+        this.radical.one()
+
+        return this
+    }
+
+    clone(): Root {
+        return new Root().from(this.index, this.radical, this.factor)
+    }
+
+    get tex(): string {
+        const output =
+            this.factor.isOne()
+                ? ''
+                : this.factor.isNegative()
+                    ? '-'
+                    : this.factor.tex
+
+        if (this.index === 1) {
+
+            return output
+        }
+
+        if (this.index === 2) {
+
+            return output
+        }
+
+        return output
+    }
+
+    get display(): string {
+        return this.factor.display
+    }
+
+    add(value: InputValue<Root>): this {
+        const rt = new Root(value)
+
+        if (
+            this.index !== rt.index &&
+            !this.radical.isEqual(rt.radical)
+        ) {
+            throw new Error("Add can only be done with two same index and radical")
+        }
+
+        this.factor.add(rt.factor)
+
+        return this
+    }
+
+    divide(value: InputValue<Root>): this {
+        return this.multiply(new Root(value).inverse())
+    }
+
+    get factor(): Fraction {
+        return this.#factor
+    }
+
+    set factor(value: Fraction) {
+        this.#factor = value
+    }
+
+    from(index: number, radical: InputValue<Fraction>, factor?: InputValue<Fraction>): this {
+        // set the index
+        this.index = index
+
+        // set the racial
+        this.radical = new Fraction(radical)
+
+        // set the factor if any
+        this.factor = factor ? new Fraction(factor) : new Fraction().one()
+
+        return this
+    }
+
+    /**
+     * convert to root(index)(radical), without factor
+     */
+    group(): this {
+
+        this.radical.multiply(this.factor.pow(this.index))
+        this.factor.one()
+
+        return this
+    }
+
+    get index(): number {
+        return this.#index
+    }
+
+    set index(value: number) {
+        if (!Number.isSafeInteger(value) || value <= 0) {
+            throw new Error("Index must be a strictly positive integer.")
+        }
+        this.#index = value
+    }
+
+    get indexAsPow(): Fraction {
+        return new Fraction(this.index).inverse()
+    }
+
+    inverse(): this {
+        this.factor.inverse()
+        this.radical.inverse()
+        return this
+    }
+
+    isEqual(root: Root): boolean {
+        return this.value === root.value
+    }
+
+    isOne(): boolean {
+        return this.factor.isOne() && this.radical.isOne()
+    }
+
+    isZero(): boolean {
+        return this.factor.isZero() || this.radical.isZero()
+    }
+
+    multiply(value: InputValue<Root>): this {
+        const rt = new Root(value)
+
+        this.factor.multiply(rt.factor)
+
+        if (this.index === rt.index) {
+            this.radical.multiply(rt.radical)
+            return this
+        }
+
+        if (this.radical.isEqual(rt.radical)) {
+            const F = this.indexAsPow.add(rt.indexAsPow).reduce()
+            this.index = F.denominator
+            this.radical = this.radical.pow(F.numerator)
+            return this
+        }
+
+        throw new Error('Multiply can only be done if radical or index as equals.')
+    }
+
+    one(): this {
+        this.radical.one()
+        this.factor.one()
+
+        return this
+    }
+
+    opposite(): this {
+        this.factor.opposite()
+        return this
+    }
+
+    pow(value: number): this {
+        this.factor.pow(value)
+
+        const g = Numeric.gcd(this.index, value)
+        this.index = this.index / g
+        this.radical.pow(value / g)
+
+        return this
+    }
+
+    get radical(): Fraction {
+        return this.#radical
+    }
+
+    set radical(value: Fraction) {
+        this.#radical = value
+    }
+
+    reduce(): this {
+        // 1. extract roots
+        // 2. avoid roots at denominator.
+
+        // Remove the roots at denominator
+        if (this.radical.isRational()) {
+            const den = this.radical.denominator
+            this.radical.denominator = 1
+            this.radical.numerator *= den
+
+            this.factor.divide(den)
+        }
+
+        // Extract the greatest root from.
+        const greatest = Numeric.greatestPower(this.radical.value, this.index)
+        this.factor = this.factor.multiply(Math.pow(greatest, 1 / this.index))
+        this.radical = this.radical.divide(greatest)
+
+        return this
+    }
+
+    root(value: number): this {
+        this.group()
+        this.index = this.index * value
+        return this
+    }
+
+    sqrt(): this {
+        return this.root(2)
+    }
+
+    subtract(value: InputValue<Root>): this {
+        const rt = new Root(value)
+
+        return this.add(rt.opposite())
+    }
+
+    public get value(): number {
+        return Numeric.numberCorrection(this.factor.value * Math.pow(this.radical.value, 1 / this.index))
+    }
+
+    zero(): this {
+        this.radical.zero()
+        this.factor.zero()
+        return this
+    }
+
+    #parse_root(value: string): this {
+        // value = a root(n)b or a root(n)(b)
+        const [factor, index_radical] = value.split('root')
+        const [index, radical] = index_radical.split(')')
+
+        this.index = +stripParenthesis(index)
+
+        this.radical = new Fraction(stripParenthesis(radical))
+
+        this.factor = factor === '' ? new Fraction().one() : new Fraction(factor)
+
+        return this
+    }
+
+    #parse_sqrt(value: string): this {
+        // value = asqrtb
+        const [factor, radical] = value.split('sqrt')
+
+        this.index = 2
+
+        this.radical = new Fraction(stripParenthesis(radical))
+
+        this.factor = factor === '' ? new Fraction().one() : new Fraction(factor)
+
+        return this
+    }
+}