pimath 0.1.40 → 0.2.1

package/src/coefficients/fraction.ts

@@ -13,19 +13,20 @@ export enum FRAC_TYPE {
  */
 
 export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction> {
-    #approximative = false
     #denominator = 1
+    #digits = 3
+    #exact = true
     #numerator = 1
     #type: FRAC_TYPE = FRAC_TYPE.frac
+    #withSign = false
 
     constructor()
     constructor(value: InputValue<Fraction>)
     constructor(numerator: number, denominator: number)
-    constructor(decimal: number, periodLength: number)
-    constructor(value?: InputValue<Fraction>, denominatorOrPeriodic?: number) {
+    constructor(value?: InputValue<Fraction>, denominator?: number) {
 
         if (value !== undefined) {
-            this.parse(value, denominatorOrPeriodic)
+            this.parse(value, denominator)
         }
 
         return this
@@ -35,10 +36,8 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
     /**
      * Parse the value to get the numerator and denominator
      * @param value : number or string to parse to get the fraction
-     * @param denominatorOrPeriodic (optional|number) : length of the periodic part: 2.333333 => 1 or denominator value
      */
-    public parse = (value: InputValue<Fraction>, denominatorOrPeriodic?: number): Fraction => {
-        let S: string[]
+    public parse = (value: InputValue<Fraction>, denominator?: number): this => {
 
         // A null value means a zero fraction.
         if (value === "") {
@@ -47,121 +46,76 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
             return this
         }
 
-        switch (typeof value) {
-            case "string":
-                // Split the string value in two parts: Numerator/Denominator
-                S = value.split('/')
-
-                // Security checks
-                if (S.length > 2) {
-                    this.#numerator = NaN
-                    // throw new Error(`The given value is not a valid fraction (${value})`)
-                }
-                if (S.map(x => x === '' || isNaN(Number(x))).includes(true)) {
-                    this.#numerator = NaN
-                    // throw new Error(`The given value is not a valid fraction (${value})`)
-                }
-
-                if (S.length === 1) {
-                    // No divide sign - it's a number
-                    return this.parse(+S[0])
-                } else if (S.length === 2) {
-                    // One divide signe
-                    // We check if the denominator is zero
-                    if (S[1] === '0') {
-                        this.#numerator = NaN
-                        this.#denominator = 1
-                    } else {
-                        this.#numerator = +S[0]
-                        this.#denominator = +S[1]
-                    }
-                } else {
-                    // More than one divide sign ?
-                    // This is not a fraction
-                    this.#numerator = NaN
-                    this.#denominator = 1
-                }
-                break
-            case "number":
-                if (Number.isSafeInteger(value)) {
-                    // The given value is an integer
-                    this.#numerator = +value
-
-                    if (denominatorOrPeriodic === undefined || !Number.isSafeInteger(denominatorOrPeriodic)) {
-                        this.#denominator = 1
-                    } else {
-                        this.#denominator = +denominatorOrPeriodic
-                    }
-                } else {
-                    // The given value is a float number
-                    // Get the number of decimals after the float sign
-                    const [, decimal] = (value.toString()).split('.')
-                    const p: number = decimal ? decimal.length : 0
-                    const power = Math.pow(10, p)
-
-                    // Detect if the decimal part is periodic or not...
-                    if (denominatorOrPeriodic === undefined) {
-                        // Transform the float number in two integer
-                        // 0.123 = 0.123*10^3 / 10^3
-                        this.#numerator = value * power
-                        this.#denominator = power
-                    } else if (Number.isSafeInteger(denominatorOrPeriodic)) {
-                        this.#numerator = value * power - Math.floor(value * Math.pow(10, p - denominatorOrPeriodic))
-                        this.denominator = power - Math.pow(10, p - denominatorOrPeriodic)
-                    }
-
-                    this.#numerator = Numeric.numberCorrection(this.#numerator)
-                    this.#denominator = Numeric.numberCorrection(this.#denominator)
-
-                    this.reduce()
-                }
-                break
-            case "object":
-                if (value instanceof Fraction) {
-                    this.#numerator = +value.numerator
-                    this.#denominator = +value.denominator
-                }
-                break
+        if (typeof value === "string") {
+            return this.fromString(value)
         }
+
+        if (typeof value === "number" && denominator===undefined) {
+            return this.fromNumber(value)
+        }
+
+        if (typeof value === "number" && typeof denominator==="number") {
+            return this.fromNumbers(value, denominator)
+        }
+
+        if (value instanceof Fraction) {
+            return this.copy(value)
+        }
+
         return this
     }
 
     public clone = (): Fraction => {
         const F = new Fraction()
-        F.numerator = +this.#numerator
-        F.denominator = +this.#denominator
+        F.numerator = this.#numerator
+        F.denominator = this.#denominator
+        F.exact = this.exact
         return F
     }
 
-    // Display getter
+    public copy(value: Fraction): this {
+        this.#numerator = value.numerator
+        this.#denominator = value.denominator
+        this.#exact = value.exact
+
+        return this
+    }
+
     public get tex(): string {
         if (this.isInfinity()) {
             return `${this.sign() === 1 ? '+' : '-'}\\infty`
         }
 
+        const plus = this.#withSign && this.isPositive() ? '+' : ''
 
-        if (this.isExact()) {
+        if (this.exact) {
             if (this.#denominator === 1) {
-                return `${this.#numerator}`
+                return `${plus}${this.#numerator}`
             } else if (this.#numerator < 0) {
                 return `-\\${this.#type}{ ${-this.#numerator} }{ ${this.#denominator} }`
             } else {
-                return `\\${this.#type}{ ${this.#numerator} }{ ${this.#denominator} }`
+                return `${plus}\\${this.#type}{ ${this.#numerator} }{ ${this.#denominator} }`
             }
         } else {
-            return this.value.toFixed(3)
+            return plus + this.value.toFixed(this.#digits)
         }
     }
 
     public get display(): string {
-        if (this.isExact()) {
+        if (this.isInfinity()) {
+            return `${this.sign() === 1 ? '+' : '-'}oo`
+        }
+
+        const plus = this.#withSign && this.isPositive() ? '+' : ''
+
+        if (this.exact) {
             if (this.#denominator === 1) {
-                return `${this.#numerator}`
+                return `${plus}${this.#numerator}`
             } else {
-                return `${this.#numerator}/${this.#denominator}`
+                return `${plus}${this.#numerator}/${this.#denominator}`
             }
         } else {
-            return this.value.toFixed(3)
+            return plus + this.value.toFixed(this.#digits)
         }
     }
 
@@ -179,12 +133,12 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
 
     public static isFraction(value: InputValue<Fraction>) {
         if (value instanceof Fraction ||
-            (typeof value === "number" && !isNaN(+value))
+            (typeof value === "number" && !isNaN(value))
         ) {
             return true
         }
 
-        if(typeof value === "string"){
+        if (typeof value === "string") {
             const [num, den] = value.split('/')
 
             return !isNaN(+num) && !isNaN(+den)
@@ -207,9 +161,6 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return M
     }
 
-    // ------------------------------------------
-    // Compare functions
-
     public static min = (...fractions: (InputValue<Fraction>)[]): Fraction => {
         let M = new Fraction(fractions[0])
 
@@ -235,6 +186,15 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return sorted
     }
 
+    public static toSameDenominateur(...fractions: InputValue<Fraction>[]): Fraction[] {
+        const F = fractions.map(x => new Fraction(x))
+        const lcm = Numeric.lcm(...F.map(x => x.denominator))
+
+        F.forEach(x => x.amplify(lcm / x.denominator))
+
+        return F
+    }
+
     public static unique = (fractions: (InputValue<Fraction>)[]): Fraction[] => {
         const unique: Record<string, boolean> = {},
             distinct: Fraction[] = []
@@ -255,15 +215,8 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
 
     public static xMultiply = (...values: (InputValue<Fraction>)[]): Fraction => {
         const R = new Fraction()
-        // Parse the value.
-        // If it's a fraction, return a clone of it
-        // If it's an integer, return the fraction F/1
-        for (const value of values) {
 
-            const F = new Fraction(value)
-            R.numerator = R.numerator * F.numerator
-            R.denominator = R.denominator * F.denominator
-        }
+        values.forEach(f=> R.multiply(f, false))
 
         return R
     }
@@ -281,6 +234,7 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
 
             this.#numerator = N * F.denominator + F.numerator * D
             this.#denominator = D * F.denominator
+            this.exact = this.exact && F.exact
         } else {
             return this.add(new Fraction(F))
         }
@@ -296,14 +250,10 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return this
     }
 
-    /**
-     * Simple function to determine if it's a fraction
-     */
     public areEquals = (...F: Fraction[]): boolean => {
         return F.every(f => f.isEqual(F[0]))
     }
 
-    // ------------------------------------------
     /**
      * Compare the current coefficient with another coefficient
      * @param F (Coefficient) The coefficient to _compare
@@ -354,6 +304,11 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return this
     }
 
+    digits(value: number): this {
+        this.#digits = value
+        return this
+    }
+
     public divide = (F: Fraction | number): Fraction => {
         const Q = new Fraction(F)
 
@@ -366,23 +321,124 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
 
         this.#numerator = N * Q.denominator
         this.#denominator = D * Q.numerator
+
+        this.exact = this.exact && Q.exact
         return this.reduce()
     }
 
+    get exact(): boolean {
+        return this.#exact
+    }
+
+    set exact(value: boolean) {
+        this.#exact = value
+    }
+
     public get frac(): this {
         this.#type = FRAC_TYPE.frac
         return this
     }
 
+    public fromNumber(value: number): this {
+        if (Number.isSafeInteger(value)) {
+            // The given value is an integer
+            this.#numerator = value
+            this.#denominator = 1
+            this.#exact = true
+            return this
+        }
+
+        // The given value is a float number
+        // Get the number of decimals after the float sign
+        const [, decimal] = (value.toString()).split('.')
+        const p: number = decimal ? decimal.length : 0
+        const power = Math.pow(10, p)
+
+        this.#numerator = value * power
+        this.#denominator = power
+
+        this.#numerator = Numeric.numberCorrection(this.#numerator)
+        this.#denominator = Numeric.numberCorrection(this.#denominator)
+
+        this.reduce()
+
+        // assume it's not exact if the decimal part is more than 10 decimals
+        this.#exact = p < 10
+
+        return this
+    }
+
+    public fromNumbers(numerator: number, denominator: number): this {
+        if (Number.isSafeInteger(numerator) && Number.isSafeInteger(denominator)) {
+            // The given value is an integer
+            this.#numerator = numerator
+            this.#denominator = denominator
+            this.#exact = true
+            return this
+        }
+
+        return this.fromNumber(numerator / denominator)
+    }
+    public fromPeriodic(value: string | number, length: number): this {
+        const [, decimal] = (value.toString()).split(/[.,]/)
+        const p: number = decimal ? decimal.length : 0
+        const power = Math.pow(10, p)
+
+        this.#numerator = (+value) * power - Math.floor((+value) * Math.pow(10, p - length))
+        this.#denominator = power - Math.pow(10, p - length)
+        this.#exact = true
+
+        return this
+    }
+
+    public fromString(value: string): this {
+        // Split the string value in two parts: Numerator/Denominator
+        const S = value.split('/').map(Number)
+
+        this.#exact = true
+
+        // Only one divide sign allowed
+        if (S.length > 2) {
+            this.#numerator = NaN
+            return this
+        }
+
+        // Each parts must be a number
+        if (S.some(x => isNaN(x))) {
+            this.#numerator = NaN
+            return this
+        }
+
+        if (S.length === 1) {
+            // No divide sign - it's a number
+            return this.fromNumber(+value)
+        }
+
+        // One divide signe
+        // We check if the denominator is zero
+        if (S[1] === 0) {
+            this.#numerator = NaN
+            this.#denominator = 1
+            return this
+        }
+
+        this.#numerator = S[0]
+        this.#denominator = S[1]
+
+        return this
+    }
+
     public infinite = (): this => {
         this.#numerator = Infinity
         this.#denominator = 1
+        this.exact = true
         return this
     }
 
     public invalid = (): this => {
         this.#numerator = NaN
         this.#denominator = 1
+        this.exact = true
         return this
     }
 
@@ -395,11 +451,6 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return this
     }
 
-    public isApproximative = (): boolean => {
-        return this.#approximative ||
-            this.#numerator.toString().length >= 15 && this.#denominator.toString().length >= 15
-    }
-
     public isEqual = (than: Fraction | number): boolean => {
         return this.compare(than, '=')
     }
@@ -408,10 +459,6 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return this.isRelative() && this.value % 2 === 0
     }
 
-    public isExact = (): boolean => {
-        return !this.isApproximative()
-    }
-
     public isFinite = (): boolean => {
         return !this.isInfinity() && !this.isNaN()
     }
@@ -428,15 +475,10 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return Math.abs(this.#numerator) === Infinity
     }
 
-    public isInverted = (p: Fraction): boolean => {
-        return this.isEqual(new Fraction().one().divide(p.clone()))
-    }
-
     public isLeq = (than: Fraction | number): boolean => {
         return this.compare(than, '<=')
     }
 
-    /* Compare shortcuts */
     public isLesser = (than: Fraction | number): boolean => {
         return this.compare(than, '<')
     }
@@ -453,12 +495,6 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return this.sign() === -1
     }
 
-    public isNegativeOne = (): boolean => {
-        return this.#numerator === -1 && this.#denominator === 1
-    }
-
-    // ------------------------------------------
-
     public isNotEqual = (than: Fraction | number): boolean => {
         return this.compare(than, '<>')
     }
@@ -475,16 +511,12 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return this.#numerator === 1 && this.#denominator === 1
     }
 
-    public isOpposite = (p: Fraction): boolean => {
-        return this.isEqual(p.clone().opposite())
-    }
-
     public isPositive = (): boolean => {
         return this.sign() === 1
     }
 
     public isRational = (): boolean => {
-        return !this.isRelative()
+        return this.exact && !this.isRelative()
     }
 
     public isReduced = (): boolean => {
@@ -492,7 +524,7 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
     }
 
     public isRelative = (): boolean => {
-        return this.clone().reduce().denominator === 1
+        return this.exact && this.clone().reduce().denominator === 1
     }
 
     public isSquare = (): boolean => {
@@ -507,12 +539,16 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return this.value > 0
     }
 
+    public isUnit(): boolean {
+        return Math.abs(this.#numerator) === 1 && this.#denominator === 1
+    }
+
     // Mathematical operations specific to fractions
     public isZero = (): boolean => {
         return this.#numerator === 0
     }
 
-    public multiply = (F: Fraction | number): this => {
+    public multiply = (F: InputValue<Fraction>, reduce = true): this => {
         // Parse the value.
         // If it's a fraction, return a clone of it
         // If it's an integer, return the fraction F/1
@@ -521,7 +557,9 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         this.#numerator = this.#numerator * Q.numerator
         this.#denominator = this.#denominator * Q.denominator
 
-        return this.reduce()
+        this.exact = this.exact && Q.exact
+
+        return reduce ? this.reduce() : this
     }
 
     // ------------------------------------------
@@ -534,9 +572,7 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
     }
 
     public one = (): this => {
-        this.#numerator = 1
-        this.#denominator = 1
-        return this
+        return this.fromNumber(1)
     }
 
     public opposite = (): this => {
@@ -572,7 +608,6 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return this
     }
 
-    // ------------------------------------------
     public reduce = (): this => {
         const g = Numeric.gcd(this.#numerator, this.#denominator)
         this.#numerator = this.#numerator / g
@@ -585,9 +620,6 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return this
     }
 
-    // ------------------------------------------
-    // Getter and setter
-
     public root = (p: number): this => {
 
         // Check if they are perfect roots..
@@ -631,7 +663,7 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
             // The fraction is not a perfect root - make it approximative
             this.#numerator = this.#numerator / this.#denominator
             this.#denominator = 1
-            this.#approximative = true
+            this.exact = false
         }
 
         // Restore the sign
@@ -670,9 +702,17 @@ export class Fraction implements IPiMathObject<Fraction>, IExpression<Fraction>
         return result === 0 ? 0 : result
     }
 
-    public zero = (): this => {
-        this.#numerator = 0
-        this.#denominator = 1
+    get withSign(): this {
+        this.#withSign = true
         return this
     }
+
+    get withoutSign(): this {
+        this.#withSign = false
+        return this
+    }
+
+    public zero = (): this => {
+        return this.fromNumber(0)
+    }
 }

package/src/coefficients/index.ts

@@ -1,4 +1,4 @@
 // Export every files from the coefficients folder
 
 export * from './fraction'
-export * from './nthRoot'
+export * from './root'