pimath 0.1.39 → 0.2.0

package/src/geometry/circle.ts

@@ -0,0 +1,456 @@
+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 | null = null
+    #equation: Equation | null = null
+    #output_style: CIRCLE_DISPLAY = CIRCLE_DISPLAY.CENTER_RADIUS
+    #squareRadius: Fraction | null = null
+
+    constructor()
+    constructor(equation: string | Equation)
+    constructor(circle: Circle)
+    constructor(center: Point, radius: Fraction | number, square?: boolean)
+    constructor(center: Point, pointThrough: Point)
+    constructor(A: Point, B: Point, C: Point)
+    constructor(...values: unknown[]) {
+        if (values.length > 0) {
+            this.parse(...values)
+        }
+    }
+
+    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
+    }
+
+    clone(): Circle {
+        return new Circle().fromCenterRadius(
+            this.center.clone(),
+            this.squareRadius.clone(),
+            true
+        )
+    }
+
+    copy(circle: Circle): this {
+        this.#center = circle.center.clone()
+        this.#squareRadius = circle.squareRadius.clone()
+
+        this.#calculateCartesian()
+
+        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()) {
+            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}`
+    }
+
+    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'
+        } else {
+            cx = `(x${this.center.x.isNegative() ? '+' : '-'}${this.center.x.clone().abs().tex})^2`
+        }
+        if (this.center.y.isZero()) {
+            cy = 'y^2'
+        } else {
+            cy = `(y${this.center.y.isNegative() ? '+' : '-'}${this.center.y.clone().abs().tex})^2`
+        }
+        return `${cx}+${cy}=${this.squareRadius.display}`
+    }
+
+    get asCanonical(): this {
+        this.#output_style = CIRCLE_DISPLAY.CANONICAL
+        return this
+    }
+
+    get asCenterRadius(): this {
+        this.#output_style = CIRCLE_DISPLAY.CENTER_RADIUS
+        return this
+    }
+
+    get center(): Point {
+        return this.#center ?? new Point()
+    }
+
+    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 {
+            this.#squareRadius = new Fraction(radius).pow(2)
+        }
+
+        this.#calculateCartesian()
+
+        return this
+    }
+
+    fromEquation(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))
+
+                this.#calculateCartesian()
+
+                return this
+            } else {
+                // The circle is not a valid circle
+                this.#reset()
+            }
+        }
+
+        return this
+    }
+
+    fromPoints(A: Point, B: Point, C: Point): this {
+        const T = new Triangle(A, B, C)
+
+        if (!T.isValid || !T.remarquables) {
+            this.#reset()
+            return this
+        }
+
+        const mAB = T.getMediators().c.clone()
+        const mAC = T.getMediators().b.clone()
+
+        return this.fromCenterPoint(
+            mAB.intersection(mAC).point,
+            A
+        )
+    }
+
+    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[] = []
+
+        triplets.forEach(triplet => {
+            // 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]]) {
+                // 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
+    }
+
+    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 {
+        if (square) {
+            this.#squareRadius = new Fraction(radius)
+        } 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().fromPointAndNormal(P, CT)]
+    }
+
+    #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)
+
+        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 => {
+            //  h = -m px + py
+            let h: Fraction
+            const equ = new Equation('y', 'x')
+
+            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)
+            }
+
+            return new Line(equ)
+        })
+
+    }
+
+    #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()
+
+        const sq = this.squareRadius.clone().multiply(slope.numerator ** 2 + slope.denominator ** 2),
+            x1 = c1.clone().multiply(a).opposite().subtract(c2.clone().multiply(b)).add(sq.clone().sqrt()),
+            x2 = c1.clone().multiply(a).opposite().subtract(c2.clone().multiply(b)).subtract(sq.clone().sqrt())
+
+        return [new Line(a, b, x1), new Line(a, b, x2)]
+    }
+}

package/src/geometry/geomMath.ts

@@ -0,0 +1,71 @@
+import {Fraction} from "../coefficients"
+import type {Vector} from "./vector"
+import type {Point} from "./point"
+
+type V = Vector | Point
+export function areVectorsEquals(v1: V, v2: V): boolean {
+    return v1.dimension === v2.dimension &&
+        v1.array.every(
+            (value, index) => {
+                return v2.array[index].isEqual(value)
+            })
+}
+
+export function areVectorsColinears(v1: V, v2: V): boolean {
+    if (v1.dimension !== v2.dimension) { return false }
+
+    // Constant of proportionality
+    const k = v2.array[0].value / v1.array[0].value
+    return v1.array.every(
+        (value, index) => {
+            return v2.array[index].value === value.value * k
+        })
+}
+
+
+export function dotProduct(v1: V, v2: V): Fraction {
+    if (v1.dimension !== v2.dimension) { return new Fraction().invalid() }
+
+    // Calculate the dot product
+    // Why does the reduce not add the last element?
+
+    return v1.array.reduce(
+        (acc, value, index) => {
+            return acc.add(value.clone().multiply(v2.array[index]))
+        }, new Fraction(0))
+}
+
+export function determinantFromVectors(...values: V[]): Fraction {
+    // TODO: Make it work for vectors of dimension n
+    // Check if the vectors are in the same dimension
+    if (values.some((value) => value.dimension !== values[0].dimension)) {
+        throw new Error('All vectors must have the same dimension')
+    }
+
+    // Check if the vectors are in dimension 2 or 3 and that the number of values is correct
+    if (values[0].dimension !== values.length ) {
+        throw new Error(`The determinant of dimension ${values[0].dimension} must have the same number of vectors (${values.length} given)`)
+    }
+
+    // Calculate the determinant 2x2
+    if (values[0].dimension === 2) {
+        return values[0].array[0].clone().multiply(values[1].array[1])
+            .subtract(values[0].array[1].clone().multiply(values[1].array[0]))
+    }
+
+    // Calculate the determinant 3x3
+    return values[0].array[0].clone()
+        .multiply(
+            values[1].array[1].clone().multiply(values[2].array[2])
+                .subtract(values[1].array[2].clone().multiply(values[2].array[1]))
+        )
+        .subtract(values[0].array[1].clone()
+            .multiply(
+                values[1].array[0].clone().multiply(values[2].array[2])
+                    .subtract(values[1].array[2].clone().multiply(values[2].array[0]))
+            )
+        )
+        .add(values[0].array[2].clone()
+            .multiply(values[1].array[0].clone().multiply(values[2].array[1])
+                .subtract(values[1].array[1].clone().multiply(values[2].array[0]))))
+}

package/src/geometry/index.ts

@@ -0,0 +1,11 @@
+// Import / export every files from the geometry folder
+
+export * from './geomMath'
+export * from './circle'
+export * from './line'
+export * from './line3'
+export * from './plane3'
+export * from './point'
+export * from './triangle'
+export * from './vector'
+export * from './sphere3'