pimath 0.1.40 → 0.2.1

package/src/geometry/circle.ts

@@ -1,19 +1,25 @@
-import { Line } from "./line"
-import { Vector } from "./vector"
-import { Numeric } from "../numeric"
-import { Fraction } from "../coefficients"
-import { Equation } from "../algebra"
-import { Polynom } from "../algebra"
-import { Monom } from "../algebra"
-import {type IPiMathObject, LinePropriety} from "../pimath.interface"
-import { Point } from "./point"
+import {Line} from "./line"
+import {Vector} from "./vector"
+import {Numeric} from "../numeric"
+import {Fraction, Root} from "../coefficients"
+import {Equation, Monom, Polynom} from "../algebra"
+import {type IPiMathObject} from "../pimath.interface"
+import {Point} from "./point"
+import {Triangle} from "./triangle"
+import {Solution} from "../analyze"
+
+enum CIRCLE_DISPLAY {
+    CANONICAL,
+    CENTER_RADIUS,
+}
 
 export class Circle
-    implements
-    IPiMathObject<Circle> {
-    #center: Point | undefined = undefined
-    #squareRadius: Fraction | undefined = undefined
-    #cartesian: Equation | undefined = undefined
+    implements IPiMathObject<Circle> {
+
+    #center: Point | null = null
+    #equation: Equation | null = null
+    #output_style: CIRCLE_DISPLAY = CIRCLE_DISPLAY.CENTER_RADIUS
+    #squareRadius: Fraction | null = null
 
     constructor()
     constructor(equation: string | Equation)
@@ -27,38 +33,69 @@ export class Circle
         }
     }
 
-    get center(): Point {
-        return this.#center ?? new Point()
+    parse(...values: unknown[]): this {
+        // 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: Vector2D, Fraction, Boolean (center, square radius, true)
+
+        if (typeof values[0] === 'string') {
+            return this.fromString(values[0])
+        }
+
+        if (values[0] instanceof Equation) {
+            return this.fromEquation(values[0])
+        }
+
+        if (values[0] instanceof Circle) {
+            return this.copy(values[0])
+        }
+
+        if (values.length === 2 &&
+            values[0] instanceof Point && values[1] instanceof Point
+        ) {
+            // Circle center through one point
+            return this.fromCenterPoint(values[0], values[1])
+        }
+
+        if (values.length >= 2 && values[0]
+            instanceof Point &&
+            (values[1] instanceof Fraction || typeof values[1] === 'number')
+        ) {
+            // Circle center through one point
+            return this.fromCenterRadius(
+                values[0], values[1],
+                (typeof values[2] === "boolean") ? values[2] : false
+            )
+        }
+
+        return this
     }
 
-    get squareRadius(): Fraction {
-        return this.#squareRadius ?? new Fraction(0)
+    clone(): Circle {
+        return new Circle().fromCenterRadius(
+            this.center.clone(),
+            this.squareRadius.clone(),
+            true
+        )
     }
 
-    get cartesian(): Equation {
-        if (this.#cartesian === undefined) { throw new Error('Cartesian equation not defined') }
+    copy(circle: Circle): this {
+        this.#center = circle.center.clone()
+        this.#squareRadius = circle.squareRadius.clone()
 
-        return this.#cartesian
-    }
+        this.#calculateCartesian()
 
-    get radius(): { tex: string, display: string, value: number } {
-        if (this.#squareRadius === undefined) { return { tex: '', display: '', value: 0 } }
-        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})`,
-                value: this.#squareRadius.clone().sqrt().value
-            }
-        }
+        return this
     }
 
     get tex(): string {
+        if (this.#output_style === CIRCLE_DISPLAY.CANONICAL) {
+            return this.equation.moveLeft().reduce().tex
+        }
 
         let cx, cy
         if (this.center.x.isZero()) {
@@ -74,11 +111,11 @@ export class Circle
         return `${cx}+${cy}=${this.squareRadius.tex}`
     }
 
-    get developed(): string {
-        return this.cartesian.tex
-    }
-
     get display(): string {
+        if (this.#output_style === CIRCLE_DISPLAY.CANONICAL) {
+            return this.equation.moveLeft().reduce().display
+        }
+
         let cx, cy
         if (this.center.x.isZero()) {
             cx = 'x^2'
@@ -93,77 +130,106 @@ export class Circle
         return `${cx}+${cy}=${this.squareRadius.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 => {
-        if (this.#center === undefined || this.#squareRadius === undefined) { throw new Error('Circle not defined') }
+    get asCanonical(): this {
+        this.#output_style = CIRCLE_DISPLAY.CANONICAL
+        return this
+    }
+
+    get asCenterRadius(): this {
+        this.#output_style = CIRCLE_DISPLAY.CENTER_RADIUS
+        return this
+    }
 
-        const distance = L.distanceTo(this.#center), radius = Math.sqrt(this.#squareRadius.value)
+    get center(): Point {
+        return this.#center ?? new Point()
+    }
 
-        if (distance.value - radius > 0.0000000001) {
-            return 0 // external
-        } else if (Math.abs(distance.value - radius) < 0.0000000001) {
-            return 1 // tangent
+    get equation(): Equation {
+        return this.#equation?.clone() ?? new Equation('0=0')
+    }
+
+    fromCenterPoint(center: Point, pointThrough: Point): this {
+        this.#center = center.clone()
+        this.#squareRadius = new Vector(this.#center, pointThrough).normSquare
+
+        this.#calculateCartesian()
+
+        return this
+    }
+
+    fromCenterRadius(center: Point, radius: Fraction | number, square?: boolean): this {
+        this.#center = center.clone()
+        if (square) {
+            this.#squareRadius = (new Fraction(radius))
         } else {
-            return 2 // secant
+            this.#squareRadius = new Fraction(radius).pow(2)
         }
+
+        this.#calculateCartesian()
+
+        return this
     }
 
-    lineIntersection = (L: Line): Point[] => {
-        const intersectionPoints: Point[] = []
-        // let solX: Fraction
+    fromEquation(equ: Equation): this {
+        // Move everything to the left.
+        equ.moveLeft()
 
-        if (this.#cartesian === undefined) { return [] }
-        const equX = this.#cartesian.clone(), lineX = L.getEquation().clone().isolate('x'),
-            lineY = L.getEquation().clone().isolate('y')
+        if (equ.degree('x').value === 2 && equ.degree('y').value === 2) {
+            // Both must be of degree 2.
+            const x2 = equ.left.monomByDegree(2, 'x'), y2 = equ.left.monomByDegree(2, 'y')
+            let x1: Monom, y1: Monom, c: Monom
 
-        if (lineX instanceof Equation && lineY instanceof Equation) {
-            equX.replaceBy('y', lineY.right).simplify()
-            equX.solve()
+            // Both square monoms must have the same coefficient.
+            if (x2.coefficient.isEqual(y2.coefficient)) {
+                equ.divide(x2.coefficient)
 
-            // TODO: rework the solutions of an equation.
-            // for (const x of equX.solutions) {
-            //     if (x.exact === false && isNaN(x.value)) {
-            //         continue
-            //     }
+                x1 = equ.left.monomByDegree(1, 'x')
+                y1 = equ.left.monomByDegree(1, 'y')
+
+                c = equ.left.monomByDegree(0)
+
+                this.#center = new Point(x1.coefficient.clone().divide(2).opposite(), y1.coefficient.clone().divide(2).opposite())
+
+                this.#squareRadius = c.coefficient.clone().opposite()
+                    .add(this.#center.x.clone().pow(2))
+                    .add(this.#center.y.clone().pow(2))
 
-            //     solX = new Fraction(x.exact === false ? x.value : x.exact)
-            //     intersectionPoints.push(new Point(solX.clone(), lineY.right.evaluate(solX)))
-            // }
+                this.#calculateCartesian()
+
+                return this
+            } else {
+                // The circle is not a valid circle
+                this.#reset()
+            }
         }
 
-        return intersectionPoints
+        return this
     }
 
-    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 !== undefined && 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 !')
+    fromPoints(A: Point, B: Point, C: Point): this {
+        const T = new Triangle(A, B, C)
+
+        if (!T.isValid || !T.remarquables) {
+            this.#reset()
+            return this
         }
-        return []
-    }
 
-    isPointOnCircle = (P: Point): boolean => {
-        return this.#cartesian?.test({ x: P.x, y: P.y }) ?? false
+        const mAB = T.getMediators().c.clone()
+        const mAC = T.getMediators().b.clone()
+
+        return this.fromCenterPoint(
+            mAB.intersection(mAC).point,
+            A
+        )
     }
 
-    getPointsOnCircle = (numberIsInteger?: boolean): Point[] => {
-        if (numberIsInteger === undefined) {
-            numberIsInteger = false
-        }
+    fromString(str: string): this {
+        return this.fromEquation(new Equation(str))
+    }
 
+    getPointsOnCircle(): Point[] {
         // It means searching for pythagorician triples that make a perfect square.
         // (x-4)^2 + (y+3)^2 = 15
-
         const triplets = Numeric.pythagoreanTripletsWithTarget(this.squareRadius.value, true)
 
         const points: Point[] = []
@@ -172,33 +238,119 @@ export class Circle
             // Allow positive / negative values
             // x-a = t  => x = a + t
             // x-a = -t => x = a - t
-
             for (const k of [[1, 1], [-1, 1], [-1, -1], [1, -1]]) {
-                points.push(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.
-                // TODO: isInListOfPoints not implemented
-                // if (!pt.isInListOfPoints(points)) {
-                //     points.push(pt)
-                // }
+                // check if the point is not already here.
+                const x = this.center.x.clone().add(k[0] * triplet[0])
+                const y = this.center.y.clone().add(k[1] * triplet[1])
+
+                if (points.every(pt => !pt.isEqualXY(x, y))) {
+                    points.push(new Point(x, y))
+                }
+
             }
         })
         return points
     }
 
-    clone(): Circle {
-        return new Circle(
-            this.center.clone(),
-            this.squareRadius.clone(),
-            true
-        )
-        // this.#center = this.center.clone()
-        // this.#squareRadius = this.squareRadius.clone()
-        // this._calculateCartesian()
-        // return this
+    isPointOnCircle = (P: Point): boolean => {
+        return this.#equation?.test({x: P.x, y: P.y}) ?? false
+    }
+
+    public isSame(circ: Circle): boolean {
+        return circ.center.isEqual(this.center)
+            && circ.radius.isEqual(this.radius)
+    }
+
+    /**
+     * Find the intersection points between the circle and a line. It can be 0, 1 or 2 points.
+     * The points are sorted depending on the direction vector of the line.
+     * @param L
+     */
+    lineIntersection(L: Line): Point[] {
+        if (this.#equation === null) return []
+
+        const center = this.center
+        const d = L.d
+        const OP = L.OA
+
+        // A = dx^2+dy^2
+        const A = d.normSquare
+
+        // B = 2 ( dx (x0-cx) + dy(y0-cy) )
+        const B = OP.x.clone().subtract(center.x).multiply(d.x)
+            .add(OP.y.clone().subtract(center.y).multiply(d.y))
+            .multiply(2)
+
+        // C = (x0-cx)^2 + (y0-cy)^2 - r^2
+        const C = OP.x.clone().subtract(center.x).pow(2)
+            .add(OP.y.clone().subtract(center.y).pow(2))
+            .subtract(this.squareRadius)
+
+        const sol = Solution.fromQuadratic(A, B, C)
+
+        if (sol.length === 0) return []
+
+        // One intersection point
+        if (sol.length === 1) { // means exact answer
+            const OX = OP.add(d.clone().multiplyByScalar(sol[0].fraction))
+            return [
+                new Point(OX.x, OX.y)
+            ]
+        }
+
+        // Two intersection points
+        const OX1 = sol[0].exact
+            ? OP.clone().add(d.clone().multiplyByScalar(sol[0].fraction))
+            : OP.clone().add(d.clone().multiplyByScalar(sol[0].value))
+
+        const OX2 = sol[1].exact
+            ? OP.clone().add(d.clone().multiplyByScalar(sol[1].fraction))
+            : OP.clone().add(d.clone().multiplyByScalar(sol[1].value))
+
+        // sort the points depending on the direction vector.
+        return [
+            new Point(OX1.x, OX1.y),
+            new Point(OX2.x, OX2.y),
+        ].sort((a, b) => {
+            // <0 => a before
+            if (d.x.isZero()) {
+                return d.y.isPositive()
+                    ? a.y.value - b.y.value
+                    : b.y.value - a.y.value
+            }
+
+            return d.x.isPositive()
+                ? a.x.value - b.x.value
+                : b.x.value - a.x.value
+        })
+    }
+
+    get radius(): Root {
+        return new Root().from(2, this.#squareRadius ?? 0)
+    }
+
+    /**
+     * Get the relative position between circle and line. It corresponds to the number of intersection.
+     * @param {Line} L
+     * @returns {number}
+     */
+    public relativePosition(L: Line): number {
+        if (this.#center === null || this.#squareRadius === null) {
+            return -1
+        }
+
+        const distance = L.distanceTo(this.#center).pow(2).value
+        const radius = this.#squareRadius.value
+
+        if (distance - radius > 0.0000000001) {
+            return 0 // external
+        }
+
+        if (Math.abs(distance - radius) < 0.0000000001) {
+            return 1 // tangent
+        }
+
+        return 2 // secant
     }
 
     setRadius(radius: Fraction | number, square?: boolean): this {
@@ -207,13 +359,48 @@ export class Circle
         } else {
             this.#squareRadius = new Fraction(radius).pow(2)
         }
+
         this.#calculateCartesian()
         return this
     }
 
+    get squareRadius(): Fraction {
+        return this.#squareRadius?.clone() ?? new Fraction(-1)
+    }
+
+    tangents = (P: Point | Fraction): Line[] => {
+        if (P instanceof Fraction) {
+            return this.#tangentsWithSlope(P)
+        }
+
+        if (this.isPointOnCircle(P)) {
+            return this.#tangentsThroughOnePointOnTheCircle(P)
+        }
+
+        if (this.#center !== null && this.#center.distanceTo(P).value > this.radius.value) {
+            return this.#tangentsThroughOnePointOutsideTheCircle(P)
+        }
+
+        return []
+    }
+
+    #calculateCartesian(): void {
+        this.#equation = (
+            new Equation(
+                new Polynom(`(x-(${this.center.x.display}))^2+(y-(${this.center.y.display}))^2`),
+                new Polynom(this.squareRadius.display))
+        ).moveLeft()
+    }
+
+    #reset() {
+        this.#center = null
+        this.#squareRadius = null
+        this.#equation = null
+    }
+
     #tangentsThroughOnePointOnTheCircle = (P: Point): Line[] => {
         const CT = new Vector(this.center, P)
-        return [new Line(P, CT, LinePropriety.Perpendicular)]
+        return [new Line().fromPointAndNormal(P, CT)]
     }
 
     #tangentsThroughOnePointOutsideTheCircle = (P: Point): Line[] => {
@@ -223,13 +410,16 @@ export class Circle
         // (m.cx - cy -m.px + py)^2 = r^2  * (m^2  + 1)
         // (m(cx-py) - (cy - py))^2 = r^2  * (m^2  + 1)
 
-        const 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')
+        const cx_px = this.center.x.clone().subtract(P.x)
+        const cy_py = this.center.y.clone().subtract(P.y)
+        const polyLeft = new Polynom('x')
+        const polyRight = new Polynom('x^2+1')
 
         polyLeft.multiply(cx_px).subtract(cy_py).pow(2)
         polyRight.multiply(this.squareRadius)
 
         const equ = new Equation(polyLeft, polyRight)
+
         const solutions = equ.solve()
 
         return solutions.map(sol => {
@@ -237,9 +427,9 @@ export class Circle
             let h: Fraction
             const equ = new Equation('y', 'x')
 
-            if (sol.exact instanceof Fraction) {
-                h = P.x.clone().opposite().multiply(sol.exact).add(P.y)
-                equ.right.multiply(sol.exact).add(h)
+            if (sol.exact) {
+                h = P.x.clone().opposite().multiply(sol.fraction).add(P.y)
+                equ.right.multiply(sol.fraction).add(h)
             } else {
                 h = P.x.clone().opposite().multiply(sol.value).add(P.y)
                 equ.right.multiply(sol.value).add(h)
@@ -263,124 +453,4 @@ export class Circle
 
         return [new Line(a, b, x1), new Line(a, b, x2)]
     }
-
-    #reset(): this {
-        this.#center = undefined
-        this.#squareRadius = undefined
-        this.#cartesian = undefined
-
-        return this
-    }
-
-    parse(...values: unknown[]): this {
-        // 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: Vector2D, 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) {
-                if (values[2] instanceof Point) {
-                    // TODO: Add the method to parse through three points
-                    // this._parseThroughtThreePoints(values[0], values[1], values[2])
-                } else {
-                    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)
-            }
-        }
-
-        // Calculate once the different values.
-        this.#calculateCartesian()
-
-
-        return this
-    }
-
-    #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()
-    }
-
-    #parseCopyCircle(circle: Circle): this {
-        this.#center = circle.center.clone()
-        this.#squareRadius = circle.squareRadius.clone()
-        this.#calculateCartesian()
-        return this
-    }
-
-    #parseCenterAndRadius(center: Point, radius: Fraction | number, square?: boolean): this {
-        this.#center = center.clone()
-        if (square) {
-            this.#squareRadius = (new Fraction(radius))
-        } else {
-            this.#squareRadius = new Fraction(radius).pow(2)
-        }
-
-        return this
-    }
-
-    #parseCenterAndPointThrough(center: Point, pointThrough: Point): this {
-        this.#center = center.clone()
-        this.#squareRadius = new Vector(this.#center, pointThrough).normSquare
-        return this
-    }
-
-    #parseEquation(equ: Equation): this {
-
-        // Move everything to the left.
-        equ.moveLeft()
-
-        if (equ.degree('x').value === 2 && equ.degree('y').value === 2) {
-            // Both must be of degree 2.
-            const x2 = equ.left.monomByDegree(2, 'x'), y2 = equ.left.monomByDegree(2, 'y')
-            let x1: Monom, y1: Monom, c: Monom
-
-            // Both square monoms must have the same coefficient.
-            if (x2.coefficient.isEqual(y2.coefficient)) {
-                equ.divide(x2.coefficient)
-
-                x1 = equ.left.monomByDegree(1, 'x')
-                y1 = equ.left.monomByDegree(1, 'y')
-
-                c = equ.left.monomByDegree(0)
-
-                this.#center = new Point(x1.coefficient.clone().divide(2).opposite(), y1.coefficient.clone().divide(2).opposite())
-
-                this.#squareRadius = c.coefficient.clone().opposite()
-                    .add(this.#center.x.clone().pow(2))
-                    .add(this.#center.y.clone().pow(2))
-
-            } else {
-                // The circle is not a valid circle
-                this.#center = undefined
-                this.#squareRadius = undefined
-            }
-        }
-        return this
-    }
-
-    // private _parseThroughtThreePoints(A: Point, B: Point, C: Point): this {
-    //     const 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
-    // }
-
 }

package/src/geometry/geomMath.ts

@@ -1,7 +1,8 @@
-import { Fraction } from "../coefficients"
-import type { Vector } from "./vector"
+import {Fraction} from "../coefficients"
+import type {Vector} from "./vector"
+import type {Point} from "./point"
 
-type V = Vector
+type V = Vector | Point
 export function areVectorsEquals(v1: V, v2: V): boolean {
     return v1.dimension === v2.dimension &&
         v1.array.every(

package/src/geometry/index.ts

@@ -1,4 +1,5 @@
 // Import / export every files from the geometry folder
+
 export * from './geomMath'
 export * from './circle'
 export * from './line'