pimath 0.1.40 → 0.2.1

package/src/coefficients/root.ts

@@ -7,10 +7,11 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
     #factor: Fraction
     #index: number
     #radical: Fraction
+    #withSign = false
 
     constructor(value?: InputValue<Root | Fraction>) {
         this.#index = 2
-        this.#factor = new Fraction().one()
+        this.#factor = new Fraction().zero()
         this.#radical = new Fraction().zero()
 
         if (value) {
@@ -35,6 +36,7 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
 
             return this
         }
+
         if (value instanceof Fraction) {
             this.index = 2
             this.factor = value.clone()
@@ -65,35 +67,60 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
     }
 
     get tex(): string {
-        const output =
-            this.factor.isOne()
-                ? ''
-                : this.factor.isNegative()
-                    ? '-'
-                    : this.factor.tex
+        // b \sqrt{}
+        // b
+        // \sqrt{}
+        // -\sqrt{}
 
-        if (this.index === 1) {
+        // Force the plus sign.
+        const plus = this.#withSign && this.factor.isPositive() ? '+' : ''
 
-            return output
-        }
+        // There is no radical - output the factor
+        if (this.#radical.isZero()) return `${plus}${this.#factor.tex}`
+
+        // The radical has an index of 1 - no radical.
+        if (this.index === 1) return `${plus}${this.factor.clone().multiply(this.radical).tex}`
 
-        if (this.index === 2) {
+        // Make the root part
+        const rad = this.index === 2
+            ? `\\sqrt{ ${this.#radical.tex} }`
+            : `\\sqrt[ ${this.index} ]{ ${this.#radical.tex} }`
 
-            return output
+        if (this.#factor.isUnit()) {
+            return this.#withSign
+                ? `${this.#factor.isOne() ? plus : '-'} ${rad}`
+                : `${this.#factor.isOne() ? '' : '-'}${rad}`
         }
 
-        return output
+        return `${plus}${this.#factor.tex} ${rad}`
     }
 
     get display(): string {
-        return this.factor.display
+        const plus = this.#withSign && this.factor.isPositive() ? '+' : ''
+
+        // There is no radical - output the factor
+        if (this.#radical.isZero()) return `${plus}${this.#factor.display}`
+
+        // The radical has an index of 1 - no radical.
+        if (this.index === 1) return `${plus}${this.factor.clone().multiply(this.radical).display}`
+
+        // Make the root part
+        const rad = this.index === 2
+            ? `sqrt(${this.#radical.tex})`
+            : `root(${this.index})(${this.#radical.display})`
+
+        if (this.#factor.isUnit()) return `${this.#factor.isOne() ? plus : '-'}${rad}`
+
+        return `${plus}${this.#factor.display}${rad}`
     }
 
     add(value: InputValue<Root>): this {
-        const rt = new Root(value)
+        // start by reducing
+        this.reduce()
+        const rt = new Root(value).reduce()
 
         if (
-            this.index !== rt.index &&
+            this.index !== rt.index ||
             !this.radical.isEqual(rt.radical)
         ) {
             throw new Error("Add can only be done with two same index and radical")
@@ -133,7 +160,6 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
      * convert to root(index)(radical), without factor
      */
     group(): this {
-
         this.radical.multiply(this.factor.pow(this.index))
         this.factor.one()
 
@@ -169,6 +195,16 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
         return this.factor.isOne() && this.radical.isOne()
     }
 
+    isRational(): boolean {
+        const reduced = this.clone().reduce()
+
+        if(reduced.radical.isOne()) return reduced.factor.exact
+
+        if(reduced.index===1) return reduced.factor.exact && reduced.radical.exact
+
+        return false
+    }
+
     isZero(): boolean {
         return this.factor.isZero() || this.radical.isZero()
     }
@@ -238,8 +274,9 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
 
         // 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)
+
+        this.factor.multiply(Math.pow(greatest, 1 / this.index))
+        this.radical.divide(greatest)
 
         return this
     }
@@ -264,6 +301,16 @@ export class Root implements IPiMathObject<Root>, IExpression<Root> {
         return Numeric.numberCorrection(this.factor.value * Math.pow(this.radical.value, 1 / this.index))
     }
 
+    get withSign(): this {
+        this.#withSign = true
+        return this
+    }
+
+    get withoutSign(): this {
+        this.#withSign = false
+        return this
+    }
+
     zero(): this {
         this.radical.zero()
         this.factor.zero()

package/src/geometry/TupleN.ts

@@ -0,0 +1,128 @@
+/**
+ * POint module contains everything necessary to handle 2d Points
+ * It's a "wrapper" of the Vector class.
+ * @module Point
+ */
+
+import {Fraction} from "../coefficients"
+import type {InputValue} from "../pimath.interface"
+
+export abstract class TupleN {
+    #array: Fraction[] = []
+    #onChange?: () => void
+
+    constructor(...values: InputValue<Fraction>[]) {
+        this.#array = values.map(x => new Fraction(x))
+    };
+
+    public abstract clone(): void
+
+    public copy(): Fraction[] {
+        return this.#array.map(x => x.clone())
+    }
+
+    abstract get tex(): string
+
+    abstract get display(): string
+
+    get array(): Fraction[] {
+        return this.#array
+    }
+
+    set array(value: Fraction[]) {
+        this.#array = value
+    }
+
+    get dimension(): number {
+        return this.array.length
+    }
+
+    public fromString(value: string): this {
+        // Remove the first letter if it's a parenthesis.
+        if (value.startsWith('(')) {
+            value = value.substring(1)
+        }
+
+        // Remove the last letter if it's a parenthesis.
+        if (value.endsWith(')')) {
+            value = value.substring(0, value.length - 1)
+        }
+
+        // Split comma, semi colon or single space.
+        const components = value.split(/[,;\s]/g)
+            .filter((v) => v.trim() !== '')
+
+        // there must be at least two Pages.
+        if (components.length < 2) {
+            return this
+        }
+
+        // Validate the fraction values.
+        this.#array = components.map(x => new Fraction(x))
+        return this
+    }
+
+    get onChange(): undefined | (() => void) {
+        return this.#onChange
+    }
+
+    set onChange(value: undefined | (() => void)) {
+        this.#onChange = value
+    }
+
+    setDimension(value = 2): this {
+        if (value < 2) {
+            throw new Error('Dimension must be at least 2')
+        }
+
+        if (value < this.dimension) {
+            this.#array = this.#array.slice(0, value)
+        } else if (value > this.dimension) {
+            for (let i = this.dimension; i < value; i++) {
+                this.#array.push(new Fraction(0))
+            }
+        }
+
+        return this
+    }
+
+    get x(): Fraction {
+        return this.#array[0]
+    }
+
+    set x(value: Fraction | number | string) {
+        this.#array[0] = new Fraction(value)
+        this.#onChange?.()
+    }
+
+    get y(): Fraction {
+        return this.#array[1]
+    }
+
+    set y(value: Fraction | number | string) {
+        this.#array[1] = new Fraction(value)
+        this.#onChange?.()
+    }
+
+    get z(): Fraction {
+        if (this.dimension < 3) {
+            throw new Error('Vector is not 3D')
+        }
+        return this.#array[2]
+    }
+
+    set z(value: Fraction | number | string) {
+        if (this.dimension < 3) {
+            throw new Error('Vector is not 3D')
+        }
+        this.#array[2] = new Fraction(value)
+        this.#onChange?.()
+    }
+
+    zero = (): this => {
+        this.#array.forEach(x => x.zero())
+        this.#onChange?.()
+        return this
+    }
+
+}