pimath 0.0.16 → 0.0.20

package/src/maths/algebra/rational.ts

@@ -131,17 +131,17 @@ import {Fraction} from "../coefficients/fraction";
 
                 N.divide(D)
 
-                if (N.degree(letter) > 0) {
-                    return N.coefficient.sign() * (Math.pow((value > 0 ? 1 : -1), N.degree(letter) % 2)) === 1 ? Infinity : -Infinity
+                if (N.degree(letter).isStrictlyPositive()) {
+                    return N.coefficient.sign() * (Math.pow((value > 0 ? 1 : -1), N.degree(letter).value % 2)) === 1 ? Infinity : -Infinity
                 }
-                if (N.degree(letter) === 0) {
+                if (N.degree(letter).isZero()) {
                     return N.coefficient
                 }
-                if (N.degree(letter) > 0) {
-                    return N.coefficient.sign() * (Math.pow(-1, N.degree(letter) % 2)) === 1 ? 0 : -0
+                if (N.degree(letter).isStrictlyPositive()) {
+                    return N.coefficient.sign() * (Math.pow(-1, N.degree(letter).value % 2)) === 1 ? 0 : -0
                 }
             } else {
-                return this._numerator.evaluate({letter: value}).divide(this._denominator.evaluate({letter: value}))
+                return this._numerator.evaluate({letter: new Fraction(value)}).divide(this._denominator.evaluate({letter: new Fraction(value)}))
             }
         }
     }

package/src/maths/coefficients/fraction.ts

@@ -1,4 +1,5 @@
 import {Numeric} from "../numeric";
+import {Random} from "../random";
 
 export class Fraction {
     private _numerator: number;
@@ -95,8 +96,8 @@ export class Fraction {
                 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 > 2) throw "Two many divide signs";
+                if (S.map(x => x === '' || isNaN(Number(x))).includes(true)) throw "Not a number"
 
 
                 if (S.length === 1) {
@@ -193,18 +194,26 @@ export class Fraction {
         return this;
     };
 
-    add = (F: Fraction): Fraction => {
-        let N: number = this._numerator,
-            D: number = this._denominator;
+    add = (F: Fraction | number): Fraction => {
+        if (F instanceof Fraction) {
+            let N: number = this._numerator,
+                D: number = this._denominator;
 
-        this._numerator = N * F.denominator + F.numerator * D;
-        this._denominator = D * F.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: Fraction): Fraction => {
-        return this.add(F.clone().opposed());
+    subtract = (F: Fraction | number): Fraction => {
+        if (F instanceof Fraction) {
+            return this.add(F.clone().opposed());
+        } else {
+            return this.add(-F)
+        }
     };
 
     multiply = (F: Fraction | number): Fraction => {
@@ -241,10 +250,16 @@ export class Fraction {
 
         return this;
     }
-    pow = (p: number): Fraction => {
+    pow = (p: number | Fraction): Fraction => {
+        // 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) {
@@ -287,6 +302,32 @@ export class Fraction {
         return this;
     };
 
+
+    static max = (...fractions: (Fraction|number)[]): Fraction => {
+        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: (Fraction|number)[]): Fraction => {
+        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
+    }
+
     // ------------------------------------------
     // Mathematical operations specific to fractions
     // ------------------------------------------
@@ -319,49 +360,55 @@ export class Fraction {
      * @param F (Coefficient) The coefficient to compare
      * @param sign (string| default is =): authorized values: =, <, <=, >, >= with some variations.
      */
-    compare = (F: Fraction, sign?: string): boolean => {
+    compare = (F: unknown, sign?: string): boolean => {
         if (sign === undefined) {
             sign = '=';
         }
 
+        let compareFraction: Fraction
+        if (F instanceof Fraction) {
+            compareFraction = F.clone()
+        } else {
+            compareFraction = new Fraction(F)
+        }
 
         switch (sign) {
             case '>':
-                return this.value > F.value;
+                return this.value > compareFraction.value;
             case ">=" || "=>" || "geq":
-                return this.value >= F.value;
+                return this.value >= compareFraction.value;
             case "<":
-                return this.value < F.value;
+                return this.value < compareFraction.value;
             case "<=" || "=>" || "leq":
-                return this.value <= F.value;
+                return this.value <= compareFraction.value;
             case "=":
-                // let F2: Fraction = F.clone().reduce(),
+                // let F2: Fraction = compareFraction.clone().reduce(),
                 //     F1: Fraction = this.clone().reduce();
                 // return (F1.numerator === F2.numerator && F1.denominator === F2.denominator);
-                return this.value === F.value;
+                return this.value === compareFraction.value;
             case "<>":
-                return this.value !== F.value;
+                return this.value !== compareFraction.value;
             default:
                 return false;
         }
     };
     /* Compare shortcuts */
-    lesser = (than: Fraction): Boolean => {
+    lesser = (than: Fraction | number): Boolean => {
         return this.compare(than, '<');
     };
-    leq = (than: Fraction): Boolean => {
+    leq = (than: Fraction | number): Boolean => {
         return this.compare(than, '<=');
     };
-    greater = (than: Fraction): Boolean => {
+    greater = (than: Fraction | number): Boolean => {
         return this.compare(than, '>');
     };
-    geq = (than: Fraction): Boolean => {
+    geq = (than: Fraction | number): Boolean => {
         return this.compare(than, '>=');
     };
-    isEqual = (than: Fraction): boolean => {
+    isEqual = (than: Fraction | number): boolean => {
         return this.compare(than, '=');
     }
-    isDifferent = (than: Fraction): boolean => {
+    isNotEqual = (than: Fraction | number): boolean => {
         return this.compare(than, '<>');
     }
     isOpposed = (p: Fraction): boolean => {
@@ -373,14 +420,26 @@ export class Fraction {
     isZero = (): boolean => {
         return this._numerator === 0;
     }
+    isNotZero = (): boolean => {
+        return this._numerator !== 0;
+    }
     isOne = (): boolean => {
         return this._numerator === 1 && this._denominator === 1;
     }
+    isNegativeOne = (): boolean => {
+        return this._numerator === -1 && this._denominator === 1;
+    }
     isPositive = (): boolean => {
-        return this.sign()===1;
+        return this.sign() === 1;
     }
     isNegative = (): boolean => {
-        return this.sign()===-1;
+        return this.sign() === -1;
+    }
+    isStrictlyPositive = (): boolean => {
+        return this.value > 0
+    }
+    isStrictlyNegative = (): Boolean => {
+        return this.value < 0
     }
     isNaN = (): boolean => {
         return isNaN(this._numerator);
@@ -395,7 +454,19 @@ export class Fraction {
         return Math.sqrt(this._numerator) % 1 === 0 && Math.sqrt(this._denominator) % 1 === 0
     }
     isReduced = (): boolean => {
-        return Math.abs(Numeric.gcd(this._numerator, this._denominator))===1
+        return Math.abs(Numeric.gcd(this._numerator, this._denominator)) === 1
+    }
+    isNatural = (): boolean => {
+        return this.clone().reduce().denominator === 1
+    }
+    isRational = (): boolean => {
+        return !this.isNatural()
+    }
+    isEven = (): boolean => {
+        return this.isNatural() && this.value % 2 === 0
+    }
+    isOdd = (): boolean => {
+        return this.isNatural() && this.value % 2 === 1
     }
     sign = (): number => {
         return (this._numerator * this._denominator >= 0) ? 1 : -1;

package/src/maths/geometry/circle.ts

@@ -1,47 +1,159 @@
 import {Point} from "./point";
-import {Fraction} from "../coefficients/fraction";
-import {Equation} from "../algebra/equation";
-import {Polynom} from "../algebra/polynom";
+import {Fraction} from "../coefficients";
+import {Equation, Monom, Polynom} from "../algebra";
+import {Line} from "./line";
+import {Vector} from "./vector";
 
 
 export class Circle {
     private _center: Point;
     private _radius: Fraction;
+    private _squareRadius: Fraction;
+    private _cartesian: Equation;
     private _exists: boolean;
+
     constructor(...values: any) {
         this._exists = false
 
-        if(values!==undefined){this.parse(...values)}
+        if (values !== undefined) {
+            this.parse(...values)
+        }
     }
 
-    private parse(...values: any) {
-        if(values.length===2){
-            this._center = new Point(values[0])
-            this._radius = new Fraction(values[1])
+
+    get center(): Point {
+        return this._center;
+    }
+
+    get radius(): { tex: string, display: string } {
+        if (this._squareRadius.isSquare()) {
+            return {
+                tex: this._squareRadius.clone().sqrt().tex,
+                display: this._squareRadius.clone().sqrt().display,
+            }
+        } else {
+            return {
+                tex: `\\sqrt{${this._squareRadius.tex}}`,
+                display: `sqrt(${this._squareRadius.display})`
+            }
         }
+        return this._squareRadius
     }
 
     get tex(): string {
         let cx, cy
-        if(this._center.x.isZero()){
+        if (this._center.x.isZero()) {
             cx = 'x^2'
-        }else{
-            cx = `\\left(x-${this._center.x.tex}\\right)^2`
+        } else {
+            cx = `\\left(x${this._center.x.isNegative() ? '+' : '-'}${this._center.x.clone().abs().tex}\\right)^2`
         }
-        if(this._center.y.isZero()){
+        if (this._center.y.isZero()) {
             cy = 'y^2'
-        }else{
-            cy = `\\left(y-${this._center.y.tex}\\right)^2`
+        } else {
+            cy = `\\left(y${this._center.y.isNegative() ? '+' : '-'}${this._center.y.clone().abs().tex}\\right)^2`
+        }
+        return `${cx}+${cy}=${this._squareRadius.tex}`
+    }
+
+    get developed(): string {
+        return this._cartesian.tex
+    }
+
+
+    // TODO: reformat code for better display.
+    get display(): string {
+        return this._cartesian.display
+    }
+
+    get cartesian(): Equation {
+        return this._cartesian
+    }
+
+    private parse(...values: any) {
+        if (values.length === 1 && typeof values[0] === 'string') {
+            this.checkCircle(new Equation(values[0]))
+        } else if (values.length >= 2) {
+            this._center = new Point(values[0])
+
+            if (values[1] instanceof Point) {
+                // Go through this point
+                this._squareRadius = new Vector(this._center, values[1]).normSquare
+            } else {
+                if (values[2] === true) {
+                    this._squareRadius = new Fraction(values[1])
+                } else {
+                    this._radius = new Fraction(values[1])
+                    this._squareRadius = this._radius.clone().pow(2)
+                }
+            }
+            this._cartesian = (new Equation(
+                new Polynom(`(x-(${this._center.x.display}))^2+(y-(${this._center.y.display}))^2`),
+                new Polynom(`${this._squareRadius.display}`)
+            )).moveLeft()
         }
-        return `${cx}+${cy}=${this._radius.pow(2).tex}`
     }
 
-    get developed():string {
-        let equ = new Equation(
-            new Polynom(`(x-(${this._center.x.display}))^2+(y-(${this._center.y.display}))^2`),
-            new Polynom(`${this._radius.pow(2).display}`)
-        )
 
-        return equ.moveLeft().tex;
+    checkCircle = (P: Equation): boolean => {
+        if (P.degree('x').value === 2 && P.degree('y').value === 2) {
+            // Both must be of degree 2.
+            let x2 = P.left.monomByDegree(2, 'x'),
+                y2 = P.left.monomByDegree(2, 'y'),
+                x1: Monom, y1: Monom, c: Monom
+
+            // Both square monoms must have the same coefficient.
+            if (x2.coefficient.isEqual(y2.coefficient)) {
+                P.divide(x2.coefficient)
+
+                x1 = P.left.monomByDegree(1, 'x')
+                y1 = P.left.monomByDegree(1, 'y')
+
+                c = P.left.monomByDegree(0)
+
+                this._center = new Point(
+                    x1.coefficient.clone().divide(2).opposed(),
+                    y1.coefficient.clone().divide(2).opposed()
+                )
+
+                this._squareRadius = c.coefficient.clone().opposed()
+                    .add(this._center.x.clone().pow(2))
+                    .add(this._center.y.clone().pow(2))
+
+            }
+        }
+
+        return false
+    }
+
+    /**
+     * Get the relative position between circle and line. It corresponds to the number of intersection.
+     * @param {Line} L
+     * @returns {number}
+     */
+    relativePosition = (L: Line): number => {
+        let distance = L.distanceTo(this.center),
+            radius = Math.sqrt(this._squareRadius.value)
+
+        if (distance.value - radius > 0.0000000001) {
+            return 0 // external
+        } else if (Math.abs(distance.value - radius) < 0.0000000001) {
+            return 1 // tangent
+        } else {
+            return 2 // external
+        }
+    }
+
+    lineIntersection = (L: Line): Point[] => {
+        let P1: Point, P2: Point
+
+        const equ = this._cartesian.clone(),
+            yLine = L.equation.clone().isolate('y')
+
+        if (yLine instanceof Equation) {
+            equ.replaceBy('y', yLine.right)
+            equ.solve()
+        }
+
+        return []
     }
 }