pimath 0.0.21 → 0.0.25

package/src/maths/algebra/monom.ts

@@ -19,7 +19,7 @@ export class Monom {
      * Create the monom object.
      * @param value (optional) string
      */
-    constructor(value?: string) {
+    constructor(value?: unknown) {
         this.zero();
 
         if (value !== undefined) {
@@ -279,23 +279,20 @@ export class Monom {
      * Parse a string to a monom. The string may include fraction.
      * @param inputStr
      */
-    parse = (inputStr: string): Monom => {
-        this._shutingYardToReducedMonom(inputStr)
-        //
-        // // Set the literal part.
-        // this.literalStr = inputStr;
-        //
-        // // Get the coefficient
-        // this._coefficient = new Fraction();
-        // for (const v of [...inputStr.replace(/([a-z])|(\^[+-]?[0-9]+)/g, ',').split(',')]) {
-        //     // The value is empty.
-        //     if (v.trim() === '') {
-        //         continue;
-        //     }
-        //
-        //     // Multiply the current coefficient by the new found value.
-        //     this._coefficient.multiply(new Fraction(v.trim()));
-        // }
+    parse = (inputStr: unknown): Monom => {
+
+        if(typeof inputStr === 'string') {
+            this._shutingYardToReducedMonom(inputStr)
+        }else if(typeof inputStr ==='number') {
+            this._coefficient = new Fraction(inputStr)
+            this._literal = {}
+        }else if(inputStr instanceof Fraction) {
+            this._coefficient = inputStr.clone()
+            this._literal = {}
+        }else if(inputStr instanceof Monom){
+            this._coefficient = inputStr._coefficient.clone()
+            this._literal = this.copyLiterals(inputStr.literal)
+        }
 
         return this;
     };
@@ -386,6 +383,15 @@ export class Monom {
         return F;
     };
 
+    copyLiterals = (literal: literalType): literalType => {
+        let L:literalType = {}
+
+        for (let k in literal) {
+            L[k] = literal[k].clone()
+        }
+        return L
+    }
+
     makeSame = (M: Monom):Monom => {
         // Copy the literal parts.
         for (let k in M._literal) {

package/src/maths/algebra/polynom.ts

@@ -25,7 +25,7 @@ export class Polynom {
      * @param {string} polynomString (optional) Default polynom to parse on class creation
      * @param values
      */
-    constructor(polynomString?: string, ...values: any[]) {
+    constructor(polynomString?: string, ...values: unknown[]) {
         this._monoms = [];
         this._factors = [];
         if (polynomString !== undefined) {
@@ -149,7 +149,7 @@ export class Polynom {
      * @param inputStr
      * @param values: as string, numbers or fractions
      */
-    parse = (inputStr: string, ...values: any[]): Polynom => {
+    parse = (inputStr: string, ...values: unknown[]): Polynom => {
 
         if (values === undefined || values.length === 0) {
             inputStr = '' + inputStr;
@@ -357,7 +357,7 @@ export class Polynom {
         return this;
     };
 
-    add = (...values: any[]): Polynom => {
+    add = (...values: unknown[]): Polynom => {
 
         for (let value of values) {
             if (value instanceof Polynom) {
@@ -374,7 +374,7 @@ export class Polynom {
         return this.reduce();
     };
 
-    subtract = (...values: any[]): Polynom => {
+    subtract = (...values: unknown[]): Polynom => {
 
         for (let value of values) {
             if (value instanceof Polynom) {
@@ -391,14 +391,14 @@ export class Polynom {
         return this.reduce();
     };
 
-    multiply = (value: any): Polynom => {
+    multiply = (value: unknown): Polynom => {
         if (value instanceof Polynom) {
             return this.multiplyByPolynom(value);
         } else if (value instanceof Fraction) {
             return this.multiplyByFraction(value);
         } else if (value instanceof Monom) {
             return this.multiplyByMonom(value);
-        } else if (Number.isSafeInteger(value)) {
+        } else if (Number.isSafeInteger(value) && typeof value==='number') {
             return this.multiplyByInteger(value);
         }
 
@@ -479,10 +479,10 @@ export class Polynom {
         return {quotient, reminder};
     };
 
-    divide = (value: any): Polynom => {
-        if (value.isFraction) {
+    divide = (value: unknown): Polynom => {
+        if (value instanceof Fraction) {
             this.divideByFraction(value);
-        } else if (Number.isSafeInteger(value)) {
+        } else if (typeof value==='number' && Number.isSafeInteger(value)) {
             return this.divideByInteger(value);
         }
     }

package/src/maths/coefficients/fraction.ts

@@ -1,11 +1,15 @@
 import {Numeric} from "../numeric";
-import {Random} from "../random";
 
+/**
+ * The fraction class make possible to handle
+ * TODO: Write the documentation correctly.
+ * \\(\frac{a}{b}\\) or \\[\frac{a}{b}\\]  values.
+ */
 export class Fraction {
     private _numerator: number;
     private _denominator: number;
 
-    constructor(value?: any, denominatorOrPeriodic?: number) {
+    constructor(value?: unknown, denominatorOrPeriodic?: number) {
         this._numerator = 1;
         this._denominator = 1;
 
@@ -80,7 +84,7 @@ export class Fraction {
      * @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
      */
-    parse = (value: any, denominatorOrPeriodic?: number): Fraction => {
+    parse = (value: unknown, denominatorOrPeriodic?: number): Fraction => {
         let S: string[];
 
         // A null value means a zero fraction.
@@ -146,7 +150,7 @@ export class Fraction {
                 }
                 break;
             case "object":
-                if (value.isFraction) {
+                if (value instanceof Fraction) {
                     this._numerator = +value.numerator;
                     this._denominator = +value.denominator;
                 }
@@ -201,7 +205,7 @@ export class Fraction {
 
             this._numerator = N * F.denominator + F.numerator * D;
             this._denominator = D * F.denominator;
-        }else{
+        } else {
             return this.add(new Fraction(F))
         }
 
@@ -303,7 +307,7 @@ export class Fraction {
     };
 
 
-    static max = (...fractions: (Fraction|number)[]): Fraction => {
+    static max = (...fractions: (Fraction | number)[]): Fraction => {
         let M = new Fraction(fractions[0])
 
         for (let m of fractions) {
@@ -315,7 +319,7 @@ export class Fraction {
 
         return M
     }
-    static min = (...fractions: (Fraction|number)[]): Fraction => {
+    static min = (...fractions: (Fraction | number)[]): Fraction => {
         let M = new Fraction(fractions[0])
 
         for (let m of fractions) {

package/src/maths/coefficients/nthroot.ts

@@ -1,14 +1,21 @@
+/**
+ * Nthroot is something like "a+b\sqrt{3}
+ */
 export class Nthroot {
     private _radical: number;
     private _nth: number;
     private _coefficient: number;
     private _isValid:boolean;
 
-    constructor() {
+    constructor(...values: number[]) {
         this._radical = 1;
         this._coefficient = 1;
         this._nth = 2;
         this._isValid = true;
+
+        if(values !== undefined){
+            this.parse(values[0], values[1], values[2])
+        }
     }
 
     // ------------------------------------------

package/src/maths/geometry/circle.ts

@@ -3,16 +3,15 @@ import {Fraction} from "../coefficients";
 import {Equation, Monom, Polynom} from "../algebra";
 import {Line} from "./line";
 import {Vector} from "./vector";
-
+import {Triangle} from "./triangle";
 
 export class Circle {
     private _center: Point;
-    private _radius: Fraction;
     private _squareRadius: Fraction;
     private _cartesian: Equation;
     private _exists: boolean;
 
-    constructor(...values: any) {
+    constructor(...values: unknown[]) {
         this._exists = false
 
         if (values !== undefined) {
@@ -25,6 +24,15 @@ export class Circle {
         return this._center;
     }
 
+
+    get exists(): boolean {
+        return this._exists;
+    }
+
+    get squareRadius(): Fraction {
+        return this._squareRadius
+    }
+
     get radius(): { tex: string, display: string } {
         if (this._squareRadius.isSquare()) {
             return {
@@ -41,18 +49,23 @@ export class Circle {
     }
 
     get tex(): string {
-        let cx, cy
-        if (this._center.x.isZero()) {
-            cx = 'x^2'
-        } else {
-            cx = `\\left(x${this._center.x.isNegative() ? '+' : '-'}${this._center.x.clone().abs().tex}\\right)^2`
-        }
-        if (this._center.y.isZero()) {
-            cy = 'y^2'
+
+        if (this._exists) {
+            let cx, cy
+            if (this._center.x.isZero()) {
+                cx = 'x^2'
+            } else {
+                cx = `\\left(x${this._center.x.isNegative() ? '+' : '-'}${this._center.x.clone().abs().tex}\\right)^2`
+            }
+            if (this._center.y.isZero()) {
+                cy = 'y^2'
+            } else {
+                cy = `\\left(y${this._center.y.isNegative() ? '+' : '-'}${this._center.y.clone().abs().tex}\\right)^2`
+            }
+            return `${cx}+${cy}=${this._squareRadius.tex}`
         } else {
-            cy = `\\left(y${this._center.y.isNegative() ? '+' : '-'}${this._center.y.clone().abs().tex}\\right)^2`
+            return `\\text{le cercle n'existe pas.}`
         }
-        return `${cx}+${cy}=${this._squareRadius.tex}`
     }
 
     get developed(): string {
@@ -69,46 +82,119 @@ export class Circle {
         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])
+    clone(): Circle {
+        this._center = this._center.clone()
+        this._squareRadius = this._squareRadius.clone()
+        this._calculateCartesian()
+        return this
+    }
+
+    private _reset(): Circle {
+        this._center = null
+        this._squareRadius = null
+        this._cartesian = null
+        this._exists = false
+
+        return this
+    }
+
+    private parse(...values: unknown[]): Circle {
+        // Data can be given in these formats:
+        // one value, a string -> make it an Equation
+        // one value, an Equation
+        // one value, a circle -> clone it
+        // two values: two points (center and pointThrough)
+        // two values: point and Fraction (center and radius)
+        // three values: Point, Fraction, Boolean (center, square radius, true)
+
+        this._reset()
 
+        if (typeof values[0] === 'string') {
+            this._parseEquation(new Equation(values[0]))
+        } else if (values[0] instanceof Equation) {
+            this._parseEquation(values[0])
+        } else if (values[0] instanceof Circle) {
+            this._parseCopyCircle(values[0])
+        } else if (values[0] instanceof Point && values.length > 1) {
             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])
+                if (values[2] instanceof Point) {
+                    this._parseThroughtThreePoints(values[0], values[1], values[2])
                 } else {
-                    this._radius = new Fraction(values[1])
-                    this._squareRadius = this._radius.clone().pow(2)
+                    this._parseCenterAndPointThrough(values[0], values[1])
                 }
+            } else if (values[1] instanceof Fraction || typeof values[1] === 'number') {
+                this._parseCenterAndRadius(values[0], values[1], (typeof values[2] === "boolean") ? values[2] : false)
             }
-            this._cartesian = (new Equation(
-                new Polynom(`(x-(${this._center.x.display}))^2+(y-(${this._center.y.display}))^2`),
-                new Polynom(`${this._squareRadius.display}`)
-            )).moveLeft()
         }
+
+        // Calculate once the different values.
+        if(this._exists) {
+            this._calculateCartesian()
+
+            // If the square radius is zero or positive, the circle exists.
+            if (this._squareRadius !== undefined && this._squareRadius.isNegative()) {
+                this._exists = false
+            }
+        }
+
+        return this
+    }
+
+    private _calculateCartesian() {
+        this._cartesian = (new Equation(
+            new Polynom(`(x-(${this._center.x.display}))^2+(y-(${this._center.y.display}))^2`),
+            new Polynom(`${this._squareRadius.display}`)
+        )).moveLeft()
+    }
+
+    private _parseCopyCircle(circle: Circle): Circle {
+        this._center = circle.center.clone()
+        this._squareRadius = circle.squareRadius.clone()
+        this._calculateCartesian()
+        this._exists = circle.exists
+        return this
     }
 
+    private _parseCenterAndRadius(center: Point, radius: Fraction | number, square?: boolean): Circle {
+        this._center = center.clone()
+
+        if (square) {
+            this._squareRadius = (new Fraction(radius))
+        } else {
+            this._squareRadius = new Fraction(radius).pow(2)
+        }
+
+        this._exists = true
+        return this
+    }
 
-    checkCircle = (P: Equation): boolean => {
-        if (P.degree('x').value === 2 && P.degree('y').value === 2) {
+    private _parseCenterAndPointThrough(center: Point, pointThrough: Point): Circle {
+        this._center = center.clone()
+        this._squareRadius = new Vector(this._center, pointThrough).normSquare
+        this._exists = true
+        return this
+    }
+
+    private _parseEquation(equ: Equation): Circle {
+        this._exists = false
+
+        // Move everything to the left.
+        equ.moveLeft()
+
+        if (equ.degree('x').value === 2 && equ.degree('y').value === 2) {
             // Both must be of degree 2.
-            let x2 = P.left.monomByDegree(2, 'x'),
-                y2 = P.left.monomByDegree(2, 'y'),
+            let x2 = equ.left.monomByDegree(2, 'x'),
+                y2 = equ.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)
+                equ.divide(x2.coefficient)
 
-                x1 = P.left.monomByDegree(1, 'x')
-                y1 = P.left.monomByDegree(1, 'y')
+                x1 = equ.left.monomByDegree(1, 'x')
+                y1 = equ.left.monomByDegree(1, 'y')
 
-                c = P.left.monomByDegree(0)
+                c = equ.left.monomByDegree(0)
 
                 this._center = new Point(
                     x1.coefficient.clone().divide(2).opposed(),
@@ -119,10 +205,25 @@ export class Circle {
                     .add(this._center.x.clone().pow(2))
                     .add(this._center.y.clone().pow(2))
 
+                this._calculateCartesian()
+                this._exists = true
+            }else{
+                // The circle is not a valid circle
+                this._center = null
+                this._squareRadius = null
+                this._exists = false
             }
         }
+        return this
+    }
 
-        return false
+    private _parseThroughtThreePoints(A: Point, B: Point, C: Point): Circle {
+        let T = new Triangle(A, B, C),
+            mAB = T.remarquables.mediators.AB.clone(),
+            mAC = T.remarquables.mediators.AC.clone()
+        this.parse(mAB.intersection(mAC).point, A)
+
+        return this
     }
 
     /**
@@ -144,16 +245,30 @@ export class Circle {
     }
 
     lineIntersection = (L: Line): Point[] => {
-        let P1: Point, P2: Point
+        let intersectionPoints: Point[] = [], solX: Fraction
+
+        if(this._cartesian===null){return []}
+        const equX = this._cartesian.clone(),
+            lineX = L.equation.clone().isolate('x'),
+            lineY = L.equation.clone().isolate('y')
+
+        if (lineX instanceof Equation && lineY instanceof Equation) {
+            equX.replaceBy('y', lineY.right).simplify()
+            equX.solve()
 
-        const equ = this._cartesian.clone(),
-            yLine = L.equation.clone().isolate('y')
+            for(let x of equX.solutions){
+                if(x.exact===false && isNaN(x.value)){continue}
 
-        if (yLine instanceof Equation) {
-            equ.replaceBy('y', yLine.right)
-            equ.solve()
+                solX = new Fraction(x.exact===false?x.value:x.exact)
+                intersectionPoints.push(
+                    new Point(
+                        solX.clone(),
+                        lineY.right.evaluate(solX)
+                    )
+                )
+            }
         }
 
-        return []
+        return intersectionPoints
     }
 }

package/src/maths/geometry/line.ts

@@ -31,7 +31,7 @@ export class Line {
     static PERPENDICULAR = LinePropriety.Perpendicular
     static PARALLEL = LinePropriety.Parallel
 
-    constructor(...values: any) {
+    constructor(...values: unknown[]) {
 
         this._exists = false;
 
@@ -42,10 +42,6 @@ export class Line {
         return this;
     }
 
-    get isLine(): boolean {
-        return true;
-    }
-
     get exists(): boolean {
         return this._exists;
     }
@@ -189,6 +185,14 @@ export class Line {
                 (values[2] instanceof Fraction || typeof values[2] === 'number')
             ) {
                 return this.parseByCoefficient(values[0], values[1], values[2]);
+            }else if (
+                values[0] instanceof Point && values[1] instanceof Vector
+            ){
+                if(values[2] === LinePropriety.Perpendicular){
+                    return this.parseByPointAndNormal(values[0], values[1])
+                }else if (values[2] === LinePropriety.Parallel){
+                    return this.parseByPointAndVector(values[0], values[1])
+                }
             }
         }
 
@@ -308,6 +312,19 @@ export class Line {
     isSameAs = (line: Line): Boolean => {
         return this.slope.isEqual(line.slope) && this.height.isEqual(line.height);
     }
+    simplify = (): Line => {
+        let lcm = Numeric.lcm(this._a.denominator, this._b.denominator, this._c.denominator),
+            gcd = Numeric.gcd(this._a.numerator, this._b.numerator, this._c.numerator);
+
+        this.parseByCoefficient(
+            this._a.clone().multiply(lcm).divide(gcd),
+            this._b.clone().multiply(lcm).divide(gcd),
+            this._c.clone().multiply(lcm).divide(gcd),
+        )
+
+        return this
+    }
+
     simplifyDirection = (): Line => {
         let lcm = Numeric.lcm(this._d.x.denominator, this._d.y.denominator),
             gcd = Numeric.gcd(this._d.x.numerator, this._d.y.numerator);
@@ -411,19 +428,21 @@ export class Line {
         return false;
     }
 
-    getValueAtX = (value: Fraction): Fraction => {
-        const equ = this.equation.clone().isolate('y')
+    getValueAtX = (value: Fraction|number): Fraction => {
+        const equ = this.equation.clone().isolate('y'),
+            F = new Fraction(value)
 
         if(equ instanceof Equation){
-            return equ.right.evaluate({x: value})
+            return equ.right.evaluate({x: F})
         }
         return
     }
-    getValueAtY = (value: Fraction): Fraction => {
-        const equ = this.equation.clone().isolate('x')
+    getValueAtY = (value: Fraction|number): Fraction => {
+        const equ = this.equation.clone().isolate('x'),
+            F = new Fraction(value)
 
         if(equ instanceof Equation){
-            return equ.right.evaluate({y: value})
+            return equ.right.evaluate({y: F})
         }
         return
     }

package/src/maths/geometry/point.ts

@@ -2,15 +2,22 @@
  * Vector module contains everything necessary to handle 2d or 3d vectors.
  * @module Vector
  */
-import {Fraction} from "../coefficients/fraction";
+import {Fraction} from "../coefficients"
+
+/**
+ * Helper class - a way to identify an object {x: number, y: number}
+ */
+class PointXY {
+    public x: number
+    public y: number
+}
 
-//TODO: Ajouter une vérification si la droite existe.
 export class Point {
     private _x: Fraction;   // 1st component
     private _y: Fraction;   // 2nd component
     private _exist: Boolean;
 
-    constructor(...values: any) {
+    constructor(...values: unknown[]) {
         this._x = new Fraction().zero();
         this._y = new Fraction().zero();
 
@@ -21,10 +28,6 @@ export class Point {
         return this
     };
 
-    get isPoint() {
-        return true;
-    }
-
     // ------------------------------------------
     // Getter and setter
     // ------------------------------------------
@@ -66,7 +69,8 @@ export class Point {
     // Creation / parsing functions
     // ------------------------------------------
 
-    parse = (...values: any): Point => {
+
+    parse = (...values: unknown[]): Point => {
         // Initialize the value.
         this.zero();
 
@@ -81,30 +85,33 @@ export class Point {
             if (values[0] instanceof Point) {
                 this._x = values[0].x.clone()
                 this._y = values[0].y.clone()
-                return this;
+                return this
             }
 
             // Value is given as string, comma separated.
-            if(typeof values[0] === 'string'){
+            if (typeof values[0] === 'string') {
                 let xy = values[0].split(',')
-                if(xy.length===2){
+                if (xy.length === 2) {
                     this._x = new Fraction(xy[0]).reduce()
                     this._y = new Fraction(xy[1]).reduce()
-                    return this;
+                    return this
                 }
             }
 
             // Value given as an object with {x: value, y: value}
-            if (values[0].x !== undefined && values[0].y !== undefined) {
-                this._x = new Fraction(values[0].x).reduce()
-                this._y = new Fraction(values[0].y).reduce()
+            if(values[0] instanceof PointXY){
+                    this._x = new Fraction(values[0].x).reduce()
+                    this._y = new Fraction(values[0].y).reduce()
+                return this
             } else {
-                return this.zero();
+                return this.zero()
             }
         }
+
         if (values.length === 2) {
             this._x = new Fraction(values[0]).reduce()
             this._y = new Fraction(values[1]).reduce()
+            return this
         }
 
         return this;
@@ -140,8 +147,8 @@ export class Point {
     texValues = (numberOfDigits: number): string => {
         let pts = [];
 
-        pts.push(this._x.value.toFixed(numberOfDigits===undefined?2:numberOfDigits));
-        pts.push(this._y.value.toFixed(numberOfDigits===undefined?2:numberOfDigits));
+        pts.push(this._x.value.toFixed(numberOfDigits === undefined ? 2 : numberOfDigits));
+        pts.push(this._y.value.toFixed(numberOfDigits === undefined ? 2 : numberOfDigits));
 
         return `\\left(${pts.join(';')}\\right)`
     }