pimath 0.0.32 → 0.0.35

package/esm/maths/coefficients/fraction.js

@@ -2,10 +2,373 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Fraction = void 0;
 const numeric_1 = require("../numeric");
+/**
+ * The fraction class make possible to handle
+ * TODO: Write the documentation correctly.
+ * \\(\frac{a}{b}\\) or \\[\frac{a}{b}\\]  values.
+ */
 class Fraction {
-    _numerator;
-    _denominator;
     constructor(value, denominatorOrPeriodic) {
+        // ------------------------------------------
+        // Creation / parsing functions
+        // ------------------------------------------
+        /**
+         * 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
+         */
+        this.parse = (value, denominatorOrPeriodic) => {
+            let S;
+            // A null value means a zero fraction.
+            if (value === null || value === "") {
+                this._numerator = 0;
+                this._denominator = 1;
+                return this;
+            }
+            switch (typeof value) {
+                case "string":
+                    // Split the sting value in two parts: Numerator/Denominator
+                    S = value.split('/');
+                    // Security checks
+                    if (S.length > 2)
+                        throw "Two many divide signs";
+                    if (S.map(x => x === '' || isNaN(Number(x))).includes(true))
+                        throw "Not a number";
+                    if (S.length === 1) {
+                        // No divide sign
+                        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._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
+                        let p = (value.toString()).split('.')[1].length;
+                        // Transform the float number in two integer
+                        if (denominatorOrPeriodic === undefined) {
+                            this._numerator = value * Math.pow(10, p);
+                            this._denominator = Math.pow(10, p);
+                        }
+                        else if (Number.isSafeInteger(denominatorOrPeriodic)) {
+                            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":
+                    if (value instanceof Fraction) {
+                        this._numerator = +value.numerator;
+                        this._denominator = +value.denominator;
+                    }
+                    break;
+            }
+            return this;
+        };
+        this.clone = () => {
+            let F = new Fraction();
+            F.numerator = +this._numerator;
+            F.denominator = +this._denominator;
+            return F;
+        };
+        this.zero = () => {
+            this._numerator = 0;
+            this._denominator = 1;
+            return this;
+        };
+        this.one = () => {
+            this._numerator = 1;
+            this._denominator = 1;
+            return this;
+        };
+        this.infinite = () => {
+            this._numerator = Infinity;
+            this._denominator = 1;
+            return this;
+        };
+        this.invalid = () => {
+            this._numerator = NaN;
+            this._denominator = 1;
+            return this;
+        };
+        // ------------------------------------------
+        // Mathematical operations
+        // ------------------------------------------
+        this.opposed = () => {
+            this._numerator = -this._numerator;
+            return this;
+        };
+        this.add = (F) => {
+            if (F instanceof Fraction) {
+                let N = this._numerator, D = this._denominator;
+                this._numerator = N * F.denominator + F.numerator * D;
+                this._denominator = D * F.denominator;
+            }
+            else {
+                return this.add(new Fraction(F));
+            }
+            return this.reduce();
+        };
+        this.subtract = (F) => {
+            if (F instanceof Fraction) {
+                return this.add(F.clone().opposed());
+            }
+            else {
+                return this.add(-F);
+            }
+        };
+        this.multiply = (F) => {
+            // Parse the value.
+            // If it's a fraction, return a clone of it
+            // If it's an integer, return the fraction F/1
+            let Q = new Fraction(F);
+            this._numerator = this._numerator * Q.numerator;
+            this._denominator = this._denominator * Q.denominator;
+            return this.reduce();
+        };
+        this.divide = (F) => {
+            let Q = new Fraction(F);
+            if (Q.numerator === 0) {
+                return new Fraction().infinite();
+            }
+            let N = +this._numerator, D = +this._denominator;
+            this._numerator = N * Q.denominator;
+            this._denominator = D * Q.numerator;
+            return this.reduce();
+        };
+        this.invert = () => {
+            let n = +this._numerator, d = +this._denominator;
+            this._numerator = d;
+            this._denominator = n;
+            return this;
+        };
+        this.pow = (p) => {
+            // TODO: Fraction.pow with a value different than a safe integer !
+            if (p instanceof Fraction) {
+                return this.pow(p.value);
+            }
+            this.reduce();
+            if (p < 0) {
+                this.invert();
+            }
+            // 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;
+        };
+        this.root = (p) => {
+            // TODO: nth - root of a fraction => this will return another type of coefficient.
+            // Check if they are perfect roots..
+            if (p === 0) {
+                return this;
+            }
+            // If negative, invert the fraction
+            if (p < 0) {
+                this.invert();
+            }
+            let n = Math.pow(this._numerator, Math.abs(1 / p)), d = Math.pow(this._denominator, Math.abs(1 / p));
+            this._numerator = Math.pow(this._numerator, Math.abs(1 / p));
+            this._denominator = Math.pow(this._denominator, Math.abs(1 / p));
+            return this;
+        };
+        this.sqrt = () => {
+            return this.root(2);
+        };
+        this.abs = () => {
+            this._numerator = Math.abs(this._numerator);
+            this._denominator = Math.abs(this._denominator);
+            return this;
+        };
+        // ------------------------------------------
+        // Mathematical operations specific to fractions
+        // ------------------------------------------
+        this.reduce = () => {
+            let g = numeric_1.Numeric.gcd(this._numerator, this._denominator);
+            this._numerator = this._numerator / g;
+            this._denominator = this._denominator / g;
+            if (this._denominator < 0) {
+                this._denominator = -this._denominator;
+                this._numerator = -this._numerator;
+            }
+            return this;
+        };
+        this.amplify = (k) => {
+            if (Number.isSafeInteger(k)) {
+                this._numerator *= k;
+                this._denominator *= k;
+            }
+            return this;
+        };
+        // ------------------------------------------
+        // Compare functions
+        // ------------------------------------------
+        /**
+         * Compare the current coefficient with another coefficient
+         * @param F (Coefficient) The coefficient to compare
+         * @param sign (string| default is =): authorized values: =, <, <=, >, >= with some variations.
+         */
+        this.compare = (F, sign) => {
+            if (sign === undefined) {
+                sign = '=';
+            }
+            let compareFraction;
+            if (F instanceof Fraction) {
+                compareFraction = F.clone();
+            }
+            else {
+                compareFraction = new Fraction(F);
+            }
+            switch (sign) {
+                case '>':
+                    return this.value > compareFraction.value;
+                case ">=" || "=>" || "geq":
+                    return this.value >= compareFraction.value;
+                case "<":
+                    return this.value < compareFraction.value;
+                case "<=" || "=>" || "leq":
+                    return this.value <= compareFraction.value;
+                case "=":
+                    // let F2: Fraction = compareFraction.clone().reduce(),
+                    //     F1: Fraction = this.clone().reduce();
+                    // return (F1.numerator === F2.numerator && F1.denominator === F2.denominator);
+                    return this.value === compareFraction.value;
+                case "<>":
+                    return this.value !== compareFraction.value;
+                default:
+                    return false;
+            }
+        };
+        /* Compare shortcuts */
+        this.lesser = (than) => {
+            return this.compare(than, '<');
+        };
+        this.leq = (than) => {
+            return this.compare(than, '<=');
+        };
+        this.greater = (than) => {
+            return this.compare(than, '>');
+        };
+        this.geq = (than) => {
+            return this.compare(than, '>=');
+        };
+        this.isEqual = (than) => {
+            return this.compare(than, '=');
+        };
+        this.isNotEqual = (than) => {
+            return this.compare(than, '<>');
+        };
+        this.isOpposed = (p) => {
+            return this.isEqual(p.clone().opposed());
+        };
+        this.isInverted = (p) => {
+            return this.isEqual(new Fraction().one().divide(p.clone()));
+        };
+        this.isZero = () => {
+            return this._numerator === 0;
+        };
+        this.isNotZero = () => {
+            return this._numerator !== 0;
+        };
+        this.isOne = () => {
+            return this._numerator === 1 && this._denominator === 1;
+        };
+        this.isNegativeOne = () => {
+            return this._numerator === -1 && this._denominator === 1;
+        };
+        this.isPositive = () => {
+            return this.sign() === 1;
+        };
+        this.isNegative = () => {
+            return this.sign() === -1;
+        };
+        this.isStrictlyPositive = () => {
+            return this.value > 0;
+        };
+        this.isStrictlyNegative = () => {
+            return this.value < 0;
+        };
+        this.isNaN = () => {
+            return isNaN(this._numerator);
+        };
+        this.isInfinity = () => {
+            return this._numerator === Infinity;
+        };
+        this.isFinite = () => {
+            return !this.isInfinity();
+        };
+        this.isSquare = () => {
+            return Math.sqrt(this._numerator) % 1 === 0 && Math.sqrt(this._denominator) % 1 === 0;
+        };
+        this.isReduced = () => {
+            return Math.abs(numeric_1.Numeric.gcd(this._numerator, this._denominator)) === 1;
+        };
+        this.isNatural = () => {
+            return this.isRelative() && this.isPositive();
+        };
+        this.isRelative = () => {
+            return this.clone().reduce().denominator === 1;
+        };
+        this.isRational = () => {
+            return !this.isRelative();
+        };
+        this.isEven = () => {
+            return this.isRelative() && this.value % 2 === 0;
+        };
+        this.isOdd = () => {
+            return this.isRelative() && this.value % 2 === 1;
+        };
+        this.sign = () => {
+            return (this._numerator * this._denominator >= 0) ? 1 : -1;
+        };
+        // TODO: The rest of the functions are not used or unnecessary ?
+        /**
+         * Simple function to determine if it's a fraction
+         */
+        this.areEquals = (...F) => {
+            for (let i = 0; i < F.length; i++) {
+                if (!this.isEqual(F[i])) {
+                    return false;
+                }
+            }
+            return true;
+        };
         this._numerator = 1;
         this._denominator = 1;
         if (value !== undefined) {
@@ -16,6 +379,9 @@ class Fraction {
     get isFraction() {
         return true;
     }
+    // ------------------------------------------
+    // Getter and setter
+    // ------------------------------------------
     get numerator() {
         return this._numerator;
     }
@@ -31,6 +397,7 @@ class Fraction {
     get value() {
         return this._numerator / this._denominator;
     }
+    // Display getter
     get tex() {
         if (this._denominator === 1) {
             return `${this._numerator}`;
@@ -50,6 +417,7 @@ class Fraction {
             return `${this._numerator}/${this._denominator}`;
         }
     }
+    // Helper function to display fractions
     get frac() {
         return this.tex;
     }
@@ -59,336 +427,26 @@ class Fraction {
     get tfrac() {
         return this.tex.replace('\\frac', '\\tfrac');
     }
-    parse = (value, denominatorOrPeriodic) => {
-        let S;
-        if (value === null || value === "") {
-            this._numerator = 0;
-            this._denominator = 1;
-            return this;
-        }
-        switch (typeof value) {
-            case "string":
-                S = value.split('/');
-                if (S.length > 2)
-                    throw "Two many divide signs";
-                if (S.map(x => x === '' || isNaN(Number(x))).includes(true))
-                    throw "Not a number";
-                if (S.length === 1) {
-                    return this.parse(+S[0]);
-                }
-                else if (S.length === 2) {
-                    if (S[1] === '0') {
-                        this._numerator = NaN;
-                        this._denominator = 1;
-                    }
-                    else {
-                        this._numerator = +S[0];
-                        this._denominator = +S[1];
-                    }
-                }
-                else {
-                    this._numerator = NaN;
-                    this._denominator = 1;
-                }
-                break;
-            case "number":
-                if (Number.isSafeInteger(value)) {
-                    this._numerator = +value;
-                    if (denominatorOrPeriodic === undefined || !Number.isSafeInteger(denominatorOrPeriodic)) {
-                        this._denominator = 1;
-                    }
-                    else {
-                        this._denominator = +denominatorOrPeriodic;
-                    }
-                }
-                else {
-                    let p = (value.toString()).split('.')[1].length;
-                    if (denominatorOrPeriodic === undefined) {
-                        this._numerator = value * Math.pow(10, p);
-                        this._denominator = Math.pow(10, p);
-                    }
-                    else if (Number.isSafeInteger(denominatorOrPeriodic)) {
-                        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":
-                if (value instanceof Fraction) {
-                    this._numerator = +value.numerator;
-                    this._denominator = +value.denominator;
-                }
-                break;
-        }
-        return this;
-    };
-    clone = () => {
-        let F = new Fraction();
-        F.numerator = +this._numerator;
-        F.denominator = +this._denominator;
-        return F;
-    };
-    zero = () => {
-        this._numerator = 0;
-        this._denominator = 1;
-        return this;
-    };
-    one = () => {
-        this._numerator = 1;
-        this._denominator = 1;
-        return this;
-    };
-    infinite = () => {
-        this._numerator = Infinity;
-        this._denominator = 1;
-        return this;
-    };
-    invalid = () => {
-        this._numerator = NaN;
-        this._denominator = 1;
-        return this;
-    };
-    opposed = () => {
-        this._numerator = -this._numerator;
-        return this;
-    };
-    add = (F) => {
-        if (F instanceof Fraction) {
-            let N = this._numerator, D = this._denominator;
-            this._numerator = N * F.denominator + F.numerator * D;
-            this._denominator = D * F.denominator;
-        }
-        else {
-            return this.add(new Fraction(F));
-        }
-        return this.reduce();
-    };
-    subtract = (F) => {
-        if (F instanceof Fraction) {
-            return this.add(F.clone().opposed());
-        }
-        else {
-            return this.add(-F);
-        }
-    };
-    multiply = (F) => {
-        let Q = new Fraction(F);
-        this._numerator = this._numerator * Q.numerator;
-        this._denominator = this._denominator * Q.denominator;
-        return this.reduce();
-    };
-    divide = (F) => {
-        let Q = new Fraction(F);
-        if (Q.numerator === 0) {
-            return new Fraction().infinite();
-        }
-        let N = +this._numerator, D = +this._denominator;
-        this._numerator = N * Q.denominator;
-        this._denominator = D * Q.numerator;
-        return this.reduce();
-    };
-    invert = () => {
-        let n = +this._numerator, d = +this._denominator;
-        this._numerator = d;
-        this._denominator = n;
-        return this;
-    };
-    pow = (p) => {
-        if (p instanceof Fraction) {
-            return this.pow(p.value);
-        }
-        this.reduce();
-        if (p < 0) {
-            this.invert();
-        }
-        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;
-    };
-    root = (p) => {
-        if (p === 0) {
-            return this;
-        }
-        if (p < 0) {
-            this.invert();
-        }
-        let n = Math.pow(this._numerator, Math.abs(1 / p)), d = Math.pow(this._denominator, Math.abs(1 / p));
-        this._numerator = Math.pow(this._numerator, Math.abs(1 / p));
-        this._denominator = Math.pow(this._denominator, Math.abs(1 / p));
-        return this;
-    };
-    sqrt = () => {
-        return this.root(2);
-    };
-    abs = () => {
-        this._numerator = Math.abs(this._numerator);
-        this._denominator = Math.abs(this._denominator);
-        return this;
-    };
-    static max = (...fractions) => {
-        let M = new Fraction(fractions[0]);
-        for (let m of fractions) {
-            let compare = new Fraction(m);
-            if (compare.greater(M)) {
-                M = compare.clone();
-            }
-        }
-        return M;
-    };
-    static min = (...fractions) => {
-        let M = new Fraction(fractions[0]);
-        for (let m of fractions) {
-            let compare = new Fraction(m);
-            if (compare.lesser(M)) {
-                M = compare.clone();
-            }
-        }
-        return M;
-    };
-    reduce = () => {
-        let g = numeric_1.Numeric.gcd(this._numerator, this._denominator);
-        this._numerator = this._numerator / g;
-        this._denominator = this._denominator / g;
-        if (this._denominator < 0) {
-            this._denominator = -this._denominator;
-            this._numerator = -this._numerator;
-        }
-        return this;
-    };
-    amplify = (k) => {
-        if (Number.isSafeInteger(k)) {
-            this._numerator *= k;
-            this._denominator *= k;
-        }
-        return this;
-    };
-    compare = (F, sign) => {
-        if (sign === undefined) {
-            sign = '=';
-        }
-        let compareFraction;
-        if (F instanceof Fraction) {
-            compareFraction = F.clone();
-        }
-        else {
-            compareFraction = new Fraction(F);
-        }
-        switch (sign) {
-            case '>':
-                return this.value > compareFraction.value;
-            case ">=" || "=>" || "geq":
-                return this.value >= compareFraction.value;
-            case "<":
-                return this.value < compareFraction.value;
-            case "<=" || "=>" || "leq":
-                return this.value <= compareFraction.value;
-            case "=":
-                return this.value === compareFraction.value;
-            case "<>":
-                return this.value !== compareFraction.value;
-            default:
-                return false;
-        }
-    };
-    lesser = (than) => {
-        return this.compare(than, '<');
-    };
-    leq = (than) => {
-        return this.compare(than, '<=');
-    };
-    greater = (than) => {
-        return this.compare(than, '>');
-    };
-    geq = (than) => {
-        return this.compare(than, '>=');
-    };
-    isEqual = (than) => {
-        return this.compare(than, '=');
-    };
-    isNotEqual = (than) => {
-        return this.compare(than, '<>');
-    };
-    isOpposed = (p) => {
-        return this.isEqual(p.clone().opposed());
-    };
-    isInverted = (p) => {
-        return this.isEqual(new Fraction().one().divide(p.clone()));
-    };
-    isZero = () => {
-        return this._numerator === 0;
-    };
-    isNotZero = () => {
-        return this._numerator !== 0;
-    };
-    isOne = () => {
-        return this._numerator === 1 && this._denominator === 1;
-    };
-    isNegativeOne = () => {
-        return this._numerator === -1 && this._denominator === 1;
-    };
-    isPositive = () => {
-        return this.sign() === 1;
-    };
-    isNegative = () => {
-        return this.sign() === -1;
-    };
-    isStrictlyPositive = () => {
-        return this.value > 0;
-    };
-    isStrictlyNegative = () => {
-        return this.value < 0;
-    };
-    isNaN = () => {
-        return isNaN(this._numerator);
-    };
-    isInfinity = () => {
-        return this._numerator === Infinity;
-    };
-    isFinite = () => {
-        return !this.isInfinity();
-    };
-    isSquare = () => {
-        return Math.sqrt(this._numerator) % 1 === 0 && Math.sqrt(this._denominator) % 1 === 0;
-    };
-    isReduced = () => {
-        return Math.abs(numeric_1.Numeric.gcd(this._numerator, this._denominator)) === 1;
-    };
-    isNatural = () => {
-        return this.isRelative() && this.isPositive();
-    };
-    isRelative = () => {
-        return this.clone().reduce().denominator === 1;
-    };
-    isRational = () => {
-        return !this.isRelative();
-    };
-    isEven = () => {
-        return this.isRelative() && this.value % 2 === 0;
-    };
-    isOdd = () => {
-        return this.isRelative() && this.value % 2 === 1;
-    };
-    sign = () => {
-        return (this._numerator * this._denominator >= 0) ? 1 : -1;
-    };
-    areEquals = (...F) => {
-        for (let i = 0; i < F.length; i++) {
-            if (!this.isEqual(F[i])) {
-                return false;
-            }
-        }
-        return true;
-    };
 }
 exports.Fraction = Fraction;
+Fraction.max = (...fractions) => {
+    let M = new Fraction(fractions[0]);
+    for (let m of fractions) {
+        let compare = new Fraction(m);
+        if (compare.greater(M)) {
+            M = compare.clone();
+        }
+    }
+    return M;
+};
+Fraction.min = (...fractions) => {
+    let M = new Fraction(fractions[0]);
+    for (let m of fractions) {
+        let compare = new Fraction(m);
+        if (compare.lesser(M)) {
+            M = compare.clone();
+        }
+    }
+    return M;
+};
 //# sourceMappingURL=fraction.js.map