pimath 0.0.17 → 0.0.18

package/src/maths/algebra/monom.ts

@@ -33,10 +33,6 @@ export class Monom {
     // ------------------------------------------
     // Getter and setter
     // ------------------------------------------
-    get isMonom() {
-        return true;
-    }
-
     /**
      * Get the coefficient as fraction
      */
@@ -311,10 +307,10 @@ export class Monom {
 
         let stack: Monom[] = [], m, pow, letter, q1, q2
 
-        if(rpn.length===0){
+        if (rpn.length === 0) {
             this.zero()
             return this
-        }else if(rpn.length===1){
+        } else if (rpn.length === 1) {
             const element = rpn[0]
 
             this.one()
@@ -324,9 +320,8 @@ export class Monom {
                 this.setLetter(element.token, 1)
             }
             return this
-        }else{
+        } else {
             // Reset the monom
-            this.one()
             for (const element of rpn) {
                 if (element.tokenType === 'coefficient') {
                     let M = new Monom().one()
@@ -343,16 +338,15 @@ export class Monom {
                             q2 = (stack.pop()) || new Monom().zero()
                             q1 = (stack.pop()) || new Monom().zero()
 
-                            if(q1.isZero() && q2.isZero()){
-                                this.opposed()
-                                break
-                            }
                             stack.push(q1.subtract(q2))
+
                             break;
                         case '*':
                             // Get the last element in the stack
-                            m = (stack.pop()) || new Monom().one()
-                            this.multiply(m)
+                            q2 = (stack.pop()) || new Monom().one()
+                            q1 = (stack.pop()) || new Monom().one()
+
+                            stack.push(q1.multiply(q2))
                             break
                         case '^':
                             // get the two last elements in the stack
@@ -361,16 +355,20 @@ export class Monom {
 
                             letter = m.variables[0]
 
-                            if(letter!==undefined) {
+                            if (letter !== undefined) {
                                 m.setLetter(letter, pow)
                             }
-                            this.multiply(m.clone())
+
+                            stack.push(m)
+                            // this.multiply(m.clone())
                             break
                     }
                 }
             }
         }
 
+        this.one()
+        this.multiply(stack[0])
         return this
     }
     /**
@@ -388,6 +386,14 @@ export class Monom {
         return F;
     };
 
+    makeSame = (M: Monom):Monom => {
+        // Copy the literal parts.
+        for (let k in M._literal) {
+            this.setLetter(k, M._literal[k].clone());
+        }
+        return this
+    }
+
     /**
      * Create a zero value monom
      */
@@ -439,6 +445,9 @@ export class Monom {
     add = (...M: Monom[]): Monom => {
         for (let m of M) {
             if (this.isSameAs(m)) {
+                if(this.isZero()){
+                    this.makeSame(m)
+                }
                 this._coefficient.add(m.coefficient);
             } else {
                 console.log('Add: Is not similar: ', m.display);
@@ -454,7 +463,10 @@ export class Monom {
     subtract = (...M: Monom[]): Monom => {
         for (let m of M) {
             if (this.isSameAs(m)) {
-                this._coefficient.add(m.coefficient.clone().opposed());
+                if(this.isZero()){
+                    this.makeSame(m)
+                }
+                this._coefficient.add(m.clone().coefficient.opposed());
             } else {
                 console.log('Subtract: Is not similar: ', m.display);
             }
@@ -571,14 +583,17 @@ export class Monom {
                     M2: string[] = M.variables,
                     K: string[] = M1.concat(M2.filter((item) => M1.indexOf(item) < 0));
 
-                for (let key of K) {
-                    // The setLetter is not available in one of the monom
-                    if (this._literal[key] === undefined || M.literal[key] === undefined) {
-                        return false;
-                    }
-                    // The setLetter does not have the isSame power in each monoms.
-                    if (!this._literal[key].isEqual(M.literal[key])) {
-                        return false;
+                // To compare, both must be different than zero.
+                if (!this.isZero() && !M.isZero()) {
+                    for (let key of K) {
+                        // The setLetter is not available in one of the monom
+                        if (this._literal[key] === undefined || M.literal[key] === undefined) {
+                            return false;
+                        }
+                        // The setLetter does not have the isSame power in each monoms.
+                        if (!this._literal[key].isEqual(M.literal[key])) {
+                            return false;
+                        }
                     }
                 }
 

package/src/maths/algebra/polynom.ts

@@ -34,11 +34,6 @@ export class Polynom {
         return this;
     }
 
-    get isPolynom() {
-        return true;
-    };
-
-
     // ------------------------------------------
     // Getter and setter
     // ------------------------------------------
@@ -365,9 +360,9 @@ export class Polynom {
     add = (...values: any[]): Polynom => {
 
         for (let value of values) {
-            if (value.isPolynom) {
+            if (value instanceof Polynom) {
                 this._monoms = this._monoms.concat(value.monoms);
-            } else if (value.isMonom) {
+            } else if (value instanceof Monom) {
                 this._monoms.push(value.clone());
             } else if (Number.isSafeInteger(value)) {
                 this._monoms.push(new Monom(value.toString()));
@@ -382,9 +377,9 @@ export class Polynom {
     subtract = (...values: any[]): Polynom => {
 
         for (let value of values) {
-            if (value.isPolynom) {
+            if (value instanceof Polynom) {
                 this._monoms = this._monoms.concat(value.clone().opposed().monoms);
-            } else if (value.isMonom) {
+            } else if (value instanceof Monom) {
                 this._monoms.push(value.clone().opposed());
             } else if (Number.isSafeInteger(value)) {
                 this._monoms.push(new Monom(value.toString()).opposed());
@@ -1100,7 +1095,7 @@ export class Polynom {
         // Reduce the polynom.
         const M = this.clone().reduce();
         for (const m of M._monoms) {
-            if (m.degree(letter) === degree) {
+            if (m.degree(letter).isEqual(degree)) {
                 return m.clone();
             }
         }

package/src/maths/geometry/circle.ts

@@ -1,47 +1,134 @@
 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)
+        }
+    }
+
+
+    get center(): Point {
+        return this._center;
     }
 
     private parse(...values: any) {
-        if(values.length===2){
+        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])
-            this._radius = new Fraction(values[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])
+                } 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()
         }
     }
 
+    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
+    }
+
+    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 `${cx}+${cy}=${this._radius.pow(2).tex}`
+
+        return false
     }
 
-    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}`)
-        )
+    /**
+     * 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)
 
-        return equ.moveLeft().tex;
+        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
+        }
     }
 }

package/src/maths/geometry/line.ts

@@ -2,12 +2,17 @@
  * This class works for 2d line in a plane.
  */
 
-import {Fraction} from "../coefficients/fraction";
+import {Fraction} from "../coefficients";
 import {Vector} from "./vector";
 import {Point} from "./point";
-import {Polynom} from "../algebra/polynom";
+import {Equation, Polynom} from "../algebra";
 import {Numeric} from "../numeric";
-import {Equation} from "../algebra/equation";
+
+enum LinePropriety {
+    None,
+    Parallel,
+    Perpendicular
+}
 
 export class Line {
     // A line is defined as the canonical form
@@ -20,19 +25,30 @@ export class Line {
     private _n: Vector;
     private _exists: boolean
 
+    private _referencePropriety: LinePropriety
+    private _referenceLine: Line
+
+    static PERPENDICULAR = LinePropriety.Perpendicular
+    static PARALLEL = LinePropriety.Parallel
+
     constructor(...values: any) {
 
         this._exists = false;
 
-        if (values !== undefined) {
+        if (values.length > 0) {
             this.parse(...values);
         }
 
         return this;
     }
 
-    get isLine():boolean {return true;}
-    get exists(): boolean {return this._exists; }
+    get isLine(): boolean {
+        return true;
+    }
+
+    get exists(): boolean {
+        return this._exists;
+    }
 
     // ------------------------------------------
     // Getter and setter
@@ -40,6 +56,7 @@ export class Line {
     get equation(): Equation {
         return new Equation(new Polynom().parse('xy', this._a, this._b, this._c), new Polynom('0')).simplify();
     }
+
     get tex(): { canonical: string, mxh: string, parametric: string } {
         // canonical    =>  ax + by + c = 0
         // mxh          =>  y = -a/b x - c/b
@@ -47,7 +64,7 @@ export class Line {
 
         let canonical = this.equation;
         // Make sur the first item is positive.
-        if(this._a.isNegative()){
+        if (this._a.isNegative()) {
             canonical.multiply(-1);
         }
 
@@ -102,6 +119,10 @@ export class Line {
         return new Vector(this._a, this._b);
     }
 
+    get director(): Vector {
+        return this._d.clone()
+    }
+
     set d(value: Vector) {
         this._d = value;
     }
@@ -117,61 +138,96 @@ export class Line {
 // ------------------------------------------
     // Creation / parsing functions
     // ------------------------------------------
-    parse = (...values: any): Line => {
+    /**
+     * Parse data to a line
+     * @param {any} values
+     * @returns {Line}
+     */
+    parse = (...values: unknown[]): Line => {
         this._exists = false;
 
-        if (values.length === 3) {
-            return this.parseByCoefficient(values[0], values[1], values[2]);
-        } else if (values.length === 2) {
-            if (values[0].isPoint && values[1].isVector) {
+        // Nothing is given...
+        if (values.length === 0) {
+            return this
+        }
+
+        // One value only: already a line (clone it), an Equation, a string (as Equation)
+        if (values.length === 1) {
+            if (values[0] instanceof Line) {
+                // Already a Line
+                return values[0].clone()
+            } else if (values[0] instanceof Equation) {
+                // It's an Equation
+                return this.parseEquation(values[0])
+            } else if (typeof values[0] === "string") {
+                // It's a string - create an Equation from it.
+                try {
+                    let E = new Equation(values[0])
+                    return this.parse(E)
+                } catch (e) {
+                    return this
+                }
+            }
+        }
+
+        if (values.length === 2) {
+            if (values[0] instanceof Point && values[1] instanceof Vector) {
                 return this.parseByPointAndVector(values[0], values[1]);
-            } else if (values[0].isPoint && values[1].isPoint) {
+            } else if (values[0] instanceof Point && values[1] instanceof Point) {
                 return this.parseByPointAndVector(values[0], new Vector(values[0], values[1]));
+            } else if (values[0] instanceof Vector && values[1] instanceof Point) {
+                return this.parseByPointAndNormal(values[1], values[0])
             }
-        } else if (values.length === 1){
-            // It's a already a line - clone it !
-            if(values[0].isLine){
-                return values[0].clone();
-            }
+        }
 
-            // Maybe it's a string or an equation
-            let equ = new Equation(values[0]);
-            if(equ.isEquation){
-                // Check if it's a valid equation.
-                equ.reorder(true)
+        if (values.length === 3) {
+            if (
+                (values[0] instanceof Fraction || typeof values[0] === 'number')
+                &&
+                (values[1] instanceof Fraction || typeof values[1] === 'number')
+                &&
+                (values[2] instanceof Fraction || typeof values[2] === 'number')
+            ) {
+                return this.parseByCoefficient(values[0], values[1], values[2]);
+            }
+        }
 
-                // It must contain either x, y or both.
-                let letters = new Set(equ.letters());
+        // TODO: Add the ability to create line from a normal vector
+        console.log('Someting wrong happend while creating the line')
+        return this;
+    }
 
-                // No 'x', no 'y' in the equations
-                if(!(letters.has('x') || letters.has('y'))){return;}
+    parseEquation = (equ: Equation): Line => {
+        // Reorder the eequation
+        equ.reorder(true)
 
-                // Another letter in the equation.
-                for(let elem of ['x', 'y']){
-                    if(letters.has(elem)){
-                        letters.delete(elem)}
-                }
+        // It must contain either x, y or both.
+        let letters = new Set(equ.letters());
 
-                if(letters.size>0){
-                    console.log('Extra variable in the equation.')
-                    return this;
-                }
+        // No 'x', no 'y' in the equations
+        if (!(letters.has('x') || letters.has('y'))) {
+            return this
+        }
 
-                // Everything should be ok now...
-                return this.parseByCoefficient(equ.left.monomByLetter('x').coefficient, equ.left.monomByLetter('y').coefficient, equ.left.monomByDegree(0).coefficient)
+        // Another letter in the equation ?
+        for (let elem of ['x', 'y']) {
+            if (letters.has(elem)) {
+                letters.delete(elem)
             }
         }
-        // TODO: Add the ability to create line from a normal vector
-        console.log('Someting wrong happend while creating the line')
-        return this;
-    }
 
-    parseByCoefficient = (a: Fraction, b: Fraction, c: Fraction): Line => {
+        if (letters.size > 0) {
+            return this
+        }
+
+        // Everything should be ok now...
+        return this.parseByCoefficient(equ.left.monomByLetter('x').coefficient, equ.left.monomByLetter('y').coefficient, equ.left.monomByDegree(0).coefficient)
+    }
+    parseByCoefficient = (a: Fraction | number, b: Fraction | number, c: Fraction | number): Line => {
         this._a = new Fraction(a);
         this._b = new Fraction(b);
         this._c = new Fraction(c);
 
-        // TODO: initialize direction and reference point
         this._d = new Vector(this._b.clone(), this._a.clone().opposed());
         this._OA = new Point(new Fraction().zero(), this._c.clone());
         this._n = this._d.clone().normal();
@@ -205,6 +261,31 @@ export class Line {
         return this;
     }
 
+    parseByPointAndNormal = (P: Point, n: Vector): Line => {
+        return this.parseByCoefficient(
+            n.x,
+            n.y,
+            P.x.clone().multiply(n.x)
+                .add(P.y.clone().multiply(n.y)).opposed()
+        )
+    }
+
+    parseByPointAndLine = (P: Point, L: Line, orientation?: LinePropriety): Line => {
+
+        if (orientation === undefined) {
+            orientation = LinePropriety.Parallel
+        }
+
+        if (orientation === LinePropriety.Parallel) {
+            return this.parseByPointAndNormal(P, L.normal)
+        } else if (orientation === LinePropriety.Perpendicular) {
+            return this.parseByPointAndNormal(P, L.director)
+        }
+
+        this._exists = false
+        return this
+    }
+
     clone = (): Line => {
         this._a = this._a.clone();
         this._b = this._b.clone();
@@ -214,6 +295,7 @@ export class Line {
         this._OA = this._OA.clone();
         this._n = this._n.clone();
 
+        this._exists = this.exists
         return this;
     }
     // ------------------------------------------
@@ -320,7 +402,7 @@ export class Line {
         )
 
         // There is an intersection point
-        if(iPt.hasIntersection) {
+        if (iPt.hasIntersection) {
             return iPt.point.x.value >= Math.min(A.x.value, B.x.value)
                 && iPt.point.x.value <= Math.max(A.x.value, B.x.value)
                 && iPt.point.y.value >= Math.min(A.y.value, B.y.value)
@@ -328,36 +410,41 @@ export class Line {
         }
         return false;
     }
+
     // ------------------------------------------
     // Special functions
     // ------------------------------------------
-    canonicalAsFloatCoefficient(decimals: number): string{
-        if(decimals===undefined){
+    canonicalAsFloatCoefficient(decimals: number): string {
+        if (decimals === undefined) {
             decimals = 2;
         }
 
         let ca = this._a.value,
             cb = this._b.value,
-            cc= this._c.value,
+            cc = this._c.value,
             canonical = '';
 
-        if(!this._a.isZero()){
-            if(this._a.isOne()){
+        if (!this._a.isZero()) {
+            if (this._a.isOne()) {
                 canonical = 'x'
-            }else if(this._a.clone().opposed().isOne()){
+            } else if (this._a.clone().opposed().isOne()) {
                 canonical = '-x'
-            }else{
-                canonical = this._a.value.toFixed(decimals)+'x'
+            } else {
+                canonical = this._a.value.toFixed(decimals) + 'x'
             }
         }
 
-        if(!this._b.isZero()){
-            if(this._b.isPositive()){canonical+='+'}
+        if (!this._b.isZero()) {
+            if (this._b.isPositive()) {
+                canonical += '+'
+            }
             canonical += this._b.value.toFixed(decimals) + 'y'
         }
 
-        if(!this._c.isZero()){
-            if(this._c.isPositive()){canonical+='+'}
+        if (!this._c.isZero()) {
+            if (this._c.isPositive()) {
+                canonical += '+'
+            }
             canonical += this._c.value.toFixed(decimals)
         }
 

package/src/maths/geometry/point.ts

@@ -53,6 +53,15 @@ export class Point {
         return `\\left(${pts.join(';')}\\right)`
     }
 
+    get display(): string {
+        let pts = [];
+
+        pts.push(this._x.tex);
+        pts.push(this._y.tex);
+
+        return `(${pts.join(';')})`
+    }
+
     // ------------------------------------------
     // Creation / parsing functions
     // ------------------------------------------