pimath 0.0.33 → 0.0.34

package/src/maths/geometry/circle.ts

@@ -1,16 +1,12 @@
 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";
 
 export class Circle {
-    private _center: Point;
-    private _squareRadius: Fraction;
-    private _cartesian: Equation;
-    private _exists: boolean;
-
     constructor(...values: unknown[]) {
         this._exists = false
 
@@ -19,30 +15,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 +80,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 +183,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 +275,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 +288,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 +327,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 +338,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 +346,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 +357,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
-    }
 }

package/src/maths/geometry/line.ts

@@ -8,7 +8,7 @@ import {Point} from "./point";
 import {Equation, Polynom} from "../algebra";
 import {Numeric} from "../numeric";
 
-enum LinePropriety {
+export enum LinePropriety {
     None,
     Parallel='parallel',
     Perpendicular = 'perpendicular',

package/src/maths/geometry/point.ts

@@ -3,6 +3,8 @@
  * @module Vector
  */
 import {Fraction} from "../coefficients"
+import {Line} from "./line";
+import {Vector} from "./vector";
 
 /**
  * Helper class - a way to identify an object {x: number, y: number}
@@ -68,8 +70,6 @@ export class Point {
     // ------------------------------------------
     // Creation / parsing functions
     // ------------------------------------------
-
-
     parse = (...values: unknown[]): Point => {
         // Initialize the value.
         this.zero();
@@ -171,4 +171,27 @@ export class Point {
         }
     };
 
+    distanceTo = (item:Point|Line): { value: number, fraction: Fraction, tex: string } => {
+        let value = 0, fraction = new Fraction(), tex = ''
+
+        if(item instanceof Line){
+            return item.distanceTo(this)
+        }else if(item instanceof Point){
+            let V = new Vector(this, item)
+
+            value = V.norm
+            fraction = V.normSquare.sqrt()
+            tex = V.normSquare.isSquare()?fraction.tex:`\\sqrt{\\dfrac{ ${V.normSquare.numerator} }{ ${V.normSquare.denominator} }}`
+        }
+        return { value, fraction, tex }
+    }
+
+    get key(): string {
+      return `${this.x.display};${this.y.display}`
+}
+    isInListOfPoints = (list: Point[]): boolean => {
+        const keyList = list.map(x=>x.key)
+
+        return keyList.includes(this.key)
+    }
 }

package/src/maths/numeric.ts

@@ -89,4 +89,19 @@ export class Numeric{
             return Math.abs(a * b / Numeric.gcd(a, b));
         });
     }
+
+    static pythagoricianTripletsWithTarget(target: number, targetIsSquare?:boolean): number[][] {
+        // méthode inverse, à partir du triplet.
+        const triplets = [],
+            targetValue = targetIsSquare===true?+target:target**2
+        for(let u = 0; u <= target; u++){
+            for(let v = 0; v <=target; v++){
+                if(u**2+v**2===targetValue){
+                    triplets.push([u, v, target])
+                }
+            }
+        }
+
+        return triplets
+    }
 }

package/tests/geometry/circle.test.ts

@@ -25,4 +25,37 @@ describe('Circle', function () {
         expect(IPS[1].x.value).to.be.equal(6)
         expect(IPS[1].y.value).to.be.equal(10)
     });
+
+    it('should calculate tangents', function(){
+
+        // Through one point on the circle
+        const C = new Circle(
+            new Point(-2, 3),
+            25,
+            true
+        ), P = new Point(-5, 7);
+
+        expect(C.tangents(P).map(x=>x.tex.canonical)).to.have.all.members(['3x-4y+43=0'])
+
+        // With a slope
+        const D = new Circle('x^2+y^2+10x=2y-6'),
+            slope = new Fraction(-2, 1)
+
+        expect(D.tangents(slope).map(x=>x.tex.canonical)).to.have.all.members(['2x+y-1=0', '2x+y+19=0'])
+
+        const E = new Circle('(x-2)^2+(y-1)^2=5'),
+            P2 = new Point(6, -2)
+
+        expect(E.tangents(P2).map(x=>x.tex.canonical)).to.have.all.members(['2x+y-10=0','2x+11y+10=0'])
+
+        let P3 = new Point(2, 2)
+        expect(E.tangents(P3)).to.be.empty
+    })
+
+    it('should get a list of point on the circle', function () {
+        const C = new Circle('(x-3)^2+(y+4)^2=16'),
+            pts = C.getPointsOnCircle()
+
+        expect(pts.map(x=>x.x.display + ',' + x.y.display)).to.have.all.members([ '3,0', '3,-8', '7,-4', '-1,-4' ])
+    });
 });

package/tsconfig.json

@@ -17,12 +17,12 @@
     "outDir": "./esm/",
     "noImplicitAny": true,
     "module": "commonjs",
-    "target": "esnext",
+    "target": "es2021",
     "allowJs": true,
     "sourceMap": true,
     "moduleResolution": "node",
     "declaration": true,
-    "removeComments": true
+    "removeComments": false
   },
   "include": [
     "./src/**/*"

package/webpack-production-min.config.js

@@ -0,0 +1,26 @@
+const path = require('path');
+
+module.exports = {
+    mode: 'production',
+    entry: './src/main.ts',
+    devtool: 'source-map',
+    module: {
+        rules: [
+            {
+                test: /\.tsx?$/,
+                use: 'ts-loader',
+                exclude: /node_module/,
+            },
+        ],
+    },
+    resolve: {
+        extensions: ['.tsx','.ts', '.js'],
+    },
+    output: {
+        filename: 'pi.min.js',
+        path: path.resolve(__dirname, 'dist'),
+    },
+    optimization: {
+        minimize: true
+    }
+};

package/webpack-production.config.js

@@ -21,6 +21,6 @@ module.exports = {
         path: path.resolve(__dirname, 'dist'),
     },
     optimization: {
-        minimize: true
+        minimize: false
     }
 };