pimath 0.0.33 → 0.0.36

package/src/maths/algebra/polynom.ts

@@ -5,10 +5,10 @@
 import {literalType, Monom} from './monom';
 import {Shutingyard, ShutingyardType, Token} from '../shutingyard';
 import {Numeric} from '../numeric';
-import {Fraction} from "../coefficients";
-import {log} from "util";
+import {Fraction} from "../coefficients/fraction";
+
+export type PolynomParsingType = string | Polynom | number | Fraction | Monom
 
-export type PolynomParsingType = string|Polynom|number|Fraction|Monom
 /**
  * Polynom class can handle polynoms, reorder, resolve, ...
  * ```
@@ -120,6 +120,82 @@ export class Polynom {
         return this.variables.length;
     }
 
+    static addToken = (stack: Polynom[], element: Token): void => {
+
+        switch (element.tokenType) {
+            case ShutingyardType.COEFFICIENT:
+                stack.push(new Polynom(element.token))
+                break
+
+            case ShutingyardType.VARIABLE:
+                stack.push(new Polynom().add(new Monom(element.token)))
+                break
+
+            case ShutingyardType.CONSTANT:
+                // TODO: add constant support to Polynom parsing.
+                console.log('Actually, not supported - will be added later !')
+                break
+
+            case ShutingyardType.OPERATION:
+                if (stack.length >= 2) {
+                    const b = stack.pop(),
+                        a = stack.pop()
+
+                    if (element.token === '+') {
+                        stack.push(a.add(b))
+                    } else if (element.token === '-') {
+                        stack.push(a.subtract(b))
+                    } else if (element.token === '*') {
+                        stack.push(a.multiply(b))
+                    } else if (element.token === '/') {
+                        if (b.degree().isStrictlyPositive()) {
+                            console.log('divide by a polynom -> should create a rational polynom !')
+                        } else {
+                            stack.push(a.divide(b.monoms[0].coefficient))
+
+                        }
+                    } else if (element.token === '^') {
+                        if (b.degree().isStrictlyPositive()) {
+                            console.error('Cannot elevate a polynom with another polynom !')
+                        } else {
+                            if (b.monoms[0].coefficient.isRelative()) {
+                                // Integer power
+                                stack.push(a.pow(b.monoms[0].coefficient.value))
+                            } else {
+                                // Only allow power if the previous polynom is only a monom, without coefficient.
+                                if (a.monoms.length === 1 && a.monoms[0].coefficient.isOne()) {
+                                    for (let letter in a.monoms[0].literal) {
+                                        a.monoms[0].literal[letter].multiply(b.monoms[0].coefficient)
+                                    }
+                                    stack.push(a)
+                                } else {
+                                    console.error('Cannot have power with fraction')
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    console.log('Stack size: ', stack.length)
+                    if (element.token === '-') {
+                        stack.push(stack.pop().opposed())
+                    } else {
+                        console.log('While parsing, cannot apply ', element.token, 'to', stack[0].tex)
+                    }
+                }
+                break
+
+            case ShutingyardType.MONOM:
+                // Should never appear.
+                console.error('The monom token should not appear here')
+                break;
+
+            case ShutingyardType.FUNCTION:
+                // Should never appear.
+                console.log('The function token should not appear here - might be introduced later.')
+                break;
+        }
+    }
+
     // ------------------------------------------
     /**
      * Parse a string to a polynom.
@@ -131,12 +207,12 @@ export class Polynom {
         this._monoms = []
         this._factors = []
 
-        if(typeof inputStr === 'string') {
+        if (typeof inputStr === 'string') {
             return this._parseString(inputStr, ...values)
-        }else if(typeof inputStr === 'number' || inputStr instanceof Fraction || inputStr instanceof Monom){
+        } else if (typeof inputStr === 'number' || inputStr instanceof Fraction || inputStr instanceof Monom) {
             this._monoms.push(new Monom(inputStr))
-        }else if(inputStr instanceof Polynom){
-            for(const m of inputStr.monoms){
+        } else if (inputStr instanceof Polynom) {
+            for (const m of inputStr.monoms) {
                 this._monoms.push(m.clone())
             }
         }
@@ -144,59 +220,6 @@ export class Polynom {
         return this
     };
 
-    private _parseString(inputStr: string, ...values:unknown[]): Polynom{
-        if (values === undefined || values.length === 0) {
-            inputStr = '' + inputStr;
-            this._rawString = inputStr;
-
-            // Parse the polynom using the shutting yard algorithm
-            if (inputStr !== '' && !isNaN(Number(inputStr))) {
-                this.empty();
-                // It's a simple number.
-                let m = new Monom(inputStr);
-                // m.coefficient = new Fraction(inputStr);
-                // m.literalStr = '';
-                this.add(m);
-                return this;
-            }
-
-            // Parse the string.
-            return this.shutingYardToReducedPolynom(inputStr);
-        } else if (/^[a-z]/.test(inputStr)) {
-            // We assume the inputStr contains only letters.
-            this.empty();
-
-            let fractions = values.map(x => new Fraction(x));
-            // Multiple setLetter version
-            if (inputStr.length > 1) {
-                // TODO: check that the number of values given correspond to the letters (+1 eventually)
-                let letters = inputStr.split(''),
-                    i = 0;
-                for (let F of fractions) {
-                    let m = new Monom();
-                    m.coefficient = F.clone();
-                    m.literalStr = letters[i] || '';
-                    this.add(m);
-                    i++;
-                }
-            }
-            // Single setLetter version
-            else {
-                let n = fractions.length - 1;
-                for (let F of fractions) {
-                    let m = new Monom()
-                    m.coefficient = F.clone();
-                    m.literalStr = `${inputStr}^${n}`
-                    this.add(m);
-                    n--;
-                }
-            }
-            return this;
-        } else {
-            return this.zero();
-        }
-    }
-
 
     // ------------------------------------------
     // Creation / parsing functions
@@ -972,6 +995,59 @@ export class Polynom {
         return M;
     }
 
+    private _parseString(inputStr: string, ...values: unknown[]): Polynom {
+        if (values === undefined || values.length === 0) {
+            inputStr = '' + inputStr;
+            this._rawString = inputStr;
+
+            // Parse the polynom using the shutting yard algorithm
+            if (inputStr !== '' && !isNaN(Number(inputStr))) {
+                this.empty();
+                // It's a simple number.
+                let m = new Monom(inputStr);
+                // m.coefficient = new Fraction(inputStr);
+                // m.literalStr = '';
+                this.add(m);
+                return this;
+            }
+
+            // Parse the string.
+            return this.shutingYardToReducedPolynom(inputStr);
+        } else if (/^[a-z]/.test(inputStr)) {
+            // We assume the inputStr contains only letters.
+            this.empty();
+
+            let fractions = values.map(x => new Fraction(x));
+            // Multiple setLetter version
+            if (inputStr.length > 1) {
+                // TODO: check that the number of values given correspond to the letters (+1 eventually)
+                let letters = inputStr.split(''),
+                    i = 0;
+                for (let F of fractions) {
+                    let m = new Monom();
+                    m.coefficient = F.clone();
+                    m.literalStr = letters[i] || '';
+                    this.add(m);
+                    i++;
+                }
+            }
+            // Single setLetter version
+            else {
+                let n = fractions.length - 1;
+                for (let F of fractions) {
+                    let m = new Monom()
+                    m.coefficient = F.clone();
+                    m.literalStr = `${inputStr}^${n}`
+                    this.add(m);
+                    n--;
+                }
+            }
+            return this;
+        } else {
+            return this.zero();
+        }
+    }
+
     private genDisplay = (output?: string, forceSign?: boolean, wrapParentheses?: boolean): string => {
         let P: string = '';
 
@@ -997,82 +1073,6 @@ export class Polynom {
         return P;
     };
 
-
-    static addToken = (stack: Polynom[], element: Token): void => {
-
-        switch(element.tokenType){
-            case ShutingyardType.COEFFICIENT:
-                stack.push(new Polynom( element.token ))
-                break
-
-            case ShutingyardType.VARIABLE:
-                stack.push(new Polynom().add(new Monom(element.token)))
-                break
-
-            case ShutingyardType.CONSTANT:
-                // TODO: add constant support to Polynom parsing.
-                console.log('Actually, not supported - will be added later !')
-                break
-
-            case ShutingyardType.OPERATION:
-                if(stack.length>=2){
-                    const b = stack.pop(),
-                        a = stack.pop()
-
-                    if(element.token === '+'){
-                        stack.push(a.add(b))
-                    }else if(element.token === '-'){
-                        stack.push(a.subtract(b))
-                    }else if(element.token === '*'){
-                        stack.push(a.multiply(b))
-                    }else if(element.token === '/'){
-                        if(b.degree().isStrictlyPositive()){
-                            console.log('divide by a polynom -> should create a rational polynom !')
-                        }else {
-                            stack.push(a.divide(b.monoms[0].coefficient))
-
-                        }
-                    }else if(element.token === '^'){
-                        if(b.degree().isStrictlyPositive()) {
-                            console.error('Cannot elevate a polynom with another polynom !')
-                        }else {
-                            if(b.monoms[0].coefficient.isRelative()) {
-                                // Integer power
-                                stack.push(a.pow(b.monoms[0].coefficient.value))
-                            }else{
-                                // Only allow power if the previous polynom is only a monom, without coefficient.
-                                if(a.monoms.length===1 && a.monoms[0].coefficient.isOne()){
-                                    for (let letter in a.monoms[0].literal) {
-                                        a.monoms[0].literal[letter].multiply(b.monoms[0].coefficient)
-                                    }
-                                    stack.push(a)
-                                }else {
-                                    console.error('Cannot have power with fraction')
-                                }
-                            }
-                        }
-                    }
-                }else{
-                    console.log('Stack size: ', stack.length)
-                    if(element.token === '-'){
-                        stack.push(stack.pop().opposed())
-                    }else{
-                        console.log('While parsing, cannot apply ', element.token, 'to', stack[0].tex)
-                    }
-                }
-                break
-
-            case ShutingyardType.MONOM:
-                // Should never appear.
-                console.error('The monom token should not appear here')
-                break;
-
-            case ShutingyardType.FUNCTION:
-                // Should never appear.
-                console.log('The function token should not appear here - might be introduced later.')
-                break;
-        }
-    }
     /**
      * Main parse using a shutting yard class
      * @param inputStr

package/src/maths/algebra/rational.ts

@@ -4,7 +4,7 @@
  */
 
 import {Polynom} from "./polynom";
-import {Fraction} from "../coefficients";
+import {Fraction} from "../coefficients/fraction";
 
 /**
  * Rational class can handle rational polynoms

package/src/maths/expressions/numexp.ts

@@ -1,5 +1,5 @@
 import {Shutingyard, ShutingyardMode, ShutingyardType, tokenConstant} from "../shutingyard";
-import {Fraction} from "../coefficients";
+import {Fraction} from "../coefficients/fraction";
 
 export class NumExp {
     private _rpn: { token: string, tokenType: string }[]

package/src/maths/expressions/polynomexp.bkp.ts

@@ -1,5 +1,5 @@
-import {Polynom} from "../algebra";
-import {Fraction} from "../coefficients";
+import {Polynom} from "../algebra/polynom";
+import {Fraction} from "../coefficients/fraction";
 
 type Factor = {
     polynom: Polynom,

package/src/maths/expressions/polynomexp.ts

@@ -1,5 +1,5 @@
-import {Polynom, PolynomParsingType} from "../algebra";
-import {Fraction, FractionParsingType} from "../coefficients";
+import {Polynom, PolynomParsingType} from "../algebra/polynom";
+import {Fraction, FractionParsingType} from "../coefficients/fraction";
 
 type PolynomExpMathFunctionType = { name: string; fn: Function, tex: string }
 

package/src/maths/geometry/circle.ts

@@ -1,16 +1,14 @@
 import {Point} from "./point";
-import {Fraction} from "../coefficients";
-import {Equation, Monom, Polynom} from "../algebra";
-import {Line} from "./line";
+import {Line, LinePropriety} from "./line";
 import {Vector} from "./vector";
 import {Triangle} from "./triangle";
+import {Numeric} from "../numeric";
+import {Fraction} from "../coefficients/fraction";
+import {Equation} from "../algebra/equation";
+import {Polynom} from "../algebra/polynom";
+import {Monom} from "../algebra/monom";
 
 export class Circle {
-    private _center: Point;
-    private _squareRadius: Fraction;
-    private _cartesian: Equation;
-    private _exists: boolean;
-
     constructor(...values: unknown[]) {
         this._exists = false
 
@@ -19,30 +17,42 @@ export class Circle {
         }
     }
 
+    private _center: Point;
 
     get center(): Point {
         return this._center;
     }
 
-
-    get exists(): boolean {
-        return this._exists;
-    }
+    private _squareRadius: Fraction;
 
     get squareRadius(): Fraction {
         return this._squareRadius
     }
 
-    get radius(): { tex: string, display: string } {
+    private _cartesian: Equation;
+
+    get cartesian(): Equation {
+        return this._cartesian
+    }
+
+    private _exists: boolean;
+
+    get exists(): boolean {
+        return this._exists;
+    }
+
+    get radius(): { tex: string, display: string, value: number } {
         if (this._squareRadius.isSquare()) {
             return {
                 tex: this._squareRadius.clone().sqrt().tex,
                 display: this._squareRadius.clone().sqrt().display,
+                value: this._squareRadius.clone().sqrt().value
             }
         } else {
             return {
                 tex: `\\sqrt{${this._squareRadius.tex}}`,
-                display: `sqrt(${this._squareRadius.display})`
+                display: `sqrt(${this._squareRadius.display})`,
+                value: this._squareRadius.clone().sqrt().value
             }
         }
         return this._squareRadius
@@ -72,14 +82,100 @@ export class Circle {
         return this._cartesian.tex
     }
 
-
     // TODO: reformat code for better display.
     get display(): string {
         return this._cartesian.display
     }
 
-    get cartesian(): Equation {
-        return this._cartesian
+    /**
+     * 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 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()
+
+            for (let x of equX.solutions) {
+                if (x.exact === false && isNaN(x.value)) {
+                    continue
+                }
+
+                solX = new Fraction(x.exact === false ? x.value : x.exact)
+                intersectionPoints.push(new Point(solX.clone(), lineY.right.evaluate(solX)))
+            }
+        }
+
+        return intersectionPoints
+    }
+
+    tangents = (P: Point | Fraction): Line[] => {
+        if (P instanceof Fraction) {
+            return this._tangentsWithSlope(P)
+        } else if (this.isPointOnCircle(P)) {
+            return this._tangentsThroughOnePointOnTheCircle(P)
+        } else if (this.center.distanceTo(P).value > this.radius.value) {
+            //TODO:  Must check it's outside the circle
+            return this._tangentsThroughOnePointOutsideTheCircle(P)
+        } else {
+            console.log('No tangents as the point is inside !')
+        }
+        return []
+    }
+
+    isPointOnCircle = (P: Point): Boolean => {
+        return this._cartesian.test({x: P.x, y: P.y})
+    }
+
+    getPointsOnCircle = (numberIsInteger?: boolean): Point[] => {
+        if (numberIsInteger === undefined) {
+            numberIsInteger = false
+        }
+
+        // It means searching for pythagorician triples that make a perfect square.
+        // (x-4)^2 + (y+3)^2 = 15
+
+        let triplets = Numeric.pythagoricianTripletsWithTarget(this._squareRadius.value, true)
+
+        let points: Point[] = [], pt
+        triplets.forEach(triplet => {
+            // Allow positive / negative values
+            // x-a = t  => x = a + t
+            // x-a = -t => x = a - t
+
+            for (let k of [[1, 1], [-1, 1], [-1, -1], [1, -1]]) {
+                pt = new Point(
+                    this.center.x.clone().add(k[0] * triplet[0]),
+                    this.center.y.clone().add(k[1] * triplet[1])
+                )
+                // Check if the point is not already in points.
+                if (!pt.isInListOfPoints(points)) {
+                    points.push(pt)
+                }
+            }
+        })
+        return points
     }
 
     clone(): Circle {
@@ -89,6 +185,59 @@ export class Circle {
         return this
     }
 
+    private _tangentsThroughOnePointOnTheCircle = (P: Point): Line[] => {
+        let CT = new Vector(this._center, P)
+        return [new Line(P, CT, LinePropriety.Perpendicular)]
+    }
+
+    private _tangentsThroughOnePointOutsideTheCircle = (P: Point): Line[] => {
+        // y = mx + h
+        // px, py => h = -m px + py => mx - y -m.px + py = 0 =>
+        // Centre: cx, cy, radius: r
+        // (m.cx - cy -m.px + py)^2 = r^2  * (m^2  + 1)
+        // (m(cx-py) - (cy - py))^2 = r^2  * (m^2  + 1)
+
+        let cx_px = this.center.x.clone().subtract(P.x), cy_py = this.center.y.clone().subtract(P.y),
+            polyLeft = new Polynom('x'), polyRight = new Polynom('x^2+1')
+
+        polyLeft.multiply(cx_px).subtract(cy_py).pow(2)
+        polyRight.multiply(this.squareRadius)
+
+        let equ = new Equation(polyLeft, polyRight)
+        equ.moveLeft().simplify().solve()
+
+        return equ.solutions.map(sol => {
+            //  h = -m px + py
+            let h, equ = new Equation('y', 'x')
+
+            if (sol.exact instanceof Fraction) {
+                h = P.x.clone().opposed().multiply(sol.exact).add(P.y)
+                equ.right.multiply(sol.exact).add(h)
+            } else {
+                h = P.x.clone().opposed().multiply(sol.value).add(P.y)
+                equ.right.multiply(sol.value).add(h)
+            }
+
+            return new Line(equ)
+        })
+
+    }
+
+    private _tangentsWithSlope = (slope: Fraction): Line[] => {
+        // d(C;t)=r => ac1+bc2 + x = +- sqrt(a^2 + b^2)*r
+        // x = -ac1-bc2  +-  sqrt(a^2 + b^2)*r
+        // y = a/bx + h => ax-by + H = 0
+
+        const a = slope.numerator, b = -slope.denominator, c1 = this._center.x.clone(), c2 = this._center.y.clone(),
+            r = this._squareRadius
+
+        let sq = this._squareRadius.clone().multiply(slope.numerator ** 2 + slope.denominator ** 2),
+            x1 = c1.clone().multiply(a).opposed().subtract(c2.clone().multiply(b)).add(sq.clone().sqrt()),
+            x2 = c1.clone().multiply(a).opposed().subtract(c2.clone().multiply(b)).subtract(sq.clone().sqrt())
+
+        return [new Line(a, b, x1), new Line(a, b, x2)]
+    }
+
     private _reset(): Circle {
         this._center = null
         this._squareRadius = null
@@ -128,7 +277,7 @@ export class Circle {
         }
 
         // Calculate once the different values.
-        if(this._exists) {
+        if (this._exists) {
             this._calculateCartesian()
 
             // If the square radius is zero or positive, the circle exists.
@@ -141,10 +290,7 @@ export class Circle {
     }
 
     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()
+        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 {
@@ -183,9 +329,7 @@ export class Circle {
 
         if (equ.degree('x').value === 2 && equ.degree('y').value === 2) {
             // Both must be of degree 2.
-            let x2 = equ.left.monomByDegree(2, 'x'),
-                y2 = equ.left.monomByDegree(2, 'y'),
-                x1: Monom, y1: Monom, c: Monom
+            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)) {
@@ -196,10 +340,7 @@ export class Circle {
 
                 c = equ.left.monomByDegree(0)
 
-                this._center = new Point(
-                    x1.coefficient.clone().divide(2).opposed(),
-                    y1.coefficient.clone().divide(2).opposed()
-                )
+                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))
@@ -207,7 +348,7 @@ export class Circle {
 
                 this._calculateCartesian()
                 this._exists = true
-            }else{
+            } else {
                 // The circle is not a valid circle
                 this._center = null
                 this._squareRadius = null
@@ -218,57 +359,11 @@ export class Circle {
     }
 
     private _parseThroughtThreePoints(A: Point, B: Point, C: Point): Circle {
-        let T = new Triangle(A, B, C),
-            mAB = T.remarquables.mediators.AB.clone(),
+        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
     }
 
-    /**
-     * 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 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()
-
-            for(let x of equX.solutions){
-                if(x.exact===false && isNaN(x.value)){continue}
-
-                solX = new Fraction(x.exact===false?x.value:x.exact)
-                intersectionPoints.push(
-                    new Point(
-                        solX.clone(),
-                        lineY.right.evaluate(solX)
-                    )
-                )
-            }
-        }
-
-        return intersectionPoints
-    }
 }