pimath 0.1.39 → 0.2.0

package/src/geometry/triangle.ts

@@ -0,0 +1,482 @@
+import {Fraction} from "../coefficients"
+import {Line} from "./line"
+import {Vector} from "./vector"
+import {Point} from "./point"
+import type {InputValue, remarquableLines} from "../pimath.interface"
+import {Numeric} from "../numeric"
+
+type TRIANGLE_SIDES = 'AB' | 'AC' | 'BC'
+
+// TODO: add a check if it's a triangle or not.
+export class Triangle {
+    // This defines the triangle
+    #A: Point = new Point()
+    #B: Point = new Point()
+    #C: Point = new Point()
+    #isValid = false
+// This is calculated
+    #lines: Record<TRIANGLE_SIDES, Line> | null = null
+    #radians = true
+    #remarquables: remarquableLines = {
+        mediators: null, medians: null, heights: null, externalBisectors: null, bisectors: null
+    }
+
+    constructor(...values: unknown[]) {
+        if (values.length > 0) {
+            this.parse(...values)
+        }
+
+        return this
+    }
+
+    parse = (...values: unknown[]): this => {
+
+        if (values.length === 1) {
+            if (values[0] instanceof Triangle) {
+                return this.copy(values[0])
+            }
+        }
+
+        if (values.length === 3) {
+            // Possibilities:
+            // - Three points (or part of points, only dict for example, or array
+            // - Three lines
+            // - Three lines as text.
+            if (values.every((x: unknown) => typeof x === 'string')) {
+                // Three lines as text.
+                const [a, b, c] = values
+                return this.fromLines(a, b, c)
+            }
+
+            if (values.every((x: unknown) => x instanceof Line)) {
+                // We have three lines
+                return this.fromLines(values[0], values[1], values[2])
+            }
+
+            if (values.every((x: unknown) => (x instanceof Point))) {
+                return this.fromPoints(values[0], values[1], values[2])
+            }
+        }
+
+        if (values.length === 6) {
+            const v: Fraction[] = values.map((x: unknown) => new Fraction(x as string))
+
+            if (v.some(x => x.isNaN())) {
+                throw new Error('One of the values is not a valid number')
+            }
+
+            return this.fromCoordinates(v[0], v[1], v[2], v[3], v[4], v[5])
+        }
+
+        return this
+    }
+
+    /**
+     * Clone the Triangle class
+     */
+    clone = (): Triangle => {
+        return new Triangle(
+            this.#A.clone(),
+            this.#B.clone(),
+            this.#C.clone()
+        )
+    }
+
+    /**
+     * Copy the values from another triangle
+     * @param value
+     */
+    copy(value: Triangle): this {
+        this.#A = value.A.clone()
+        this.#B = value.B.clone()
+        this.#C = value.C.clone()
+
+        return this
+    }
+
+    get A(): Point {
+        return this.#A
+    }
+
+    set A(value: Point) {
+        this.#A = value
+        this.#A.onChange = () => this.reset()
+        this.reset()
+    }
+
+    get AB(): Vector {
+        return this.#getSegment('A', 'B')
+    }
+
+    get AC(): Vector {
+        return this.#getSegment('A', 'C')
+    }
+
+    get B(): Point {
+        return this.#B
+    }
+
+    set B(value: Point) {
+        this.#B = value
+        this.#B.onChange = () => this.reset()
+        this.reset()
+    }
+
+    get BA(): Vector {
+        return this.#getSegment('B', 'A')
+    }
+
+    get BC(): Vector {
+        return this.#getSegment('B', 'C')
+    }
+
+    get C(): Point {
+        return this.#C
+    }
+
+    set C(value: Point) {
+        this.#C = value
+        this.#C.onChange = () => this.reset()
+        this.reset()
+    }
+
+    get CA(): Vector {
+        return this.#getSegment('C', 'A')
+    }
+
+    get CB(): Vector {
+        return this.#getSegment('C', 'B')
+    }
+
+    get asDegree(): this {
+        this.#radians = false
+        return this
+    }
+
+    get asRadians(): this {
+        this.#radians = true
+        return this
+    }
+
+    fromCoordinates(
+        x1: InputValue<Fraction>, y1: InputValue<Fraction>,
+        x2: InputValue<Fraction>, y2: InputValue<Fraction>,
+        x3: InputValue<Fraction>, y3: InputValue<Fraction>): this {
+
+        return this.fromPoints(
+            new Point(x1, y1),
+            new Point(x2, y2),
+            new Point(x3, y3),
+        )
+    }
+
+    fromLines(line1: Line | string, line2: Line | string, line3: Line | string): this {
+        const AB: Line = new Line(line1).clone()
+        const BC: Line = new Line(line2).clone()
+        const AC: Line = new Line(line3).clone()
+
+        // Get the intersection points -> build the triangle using these intersection points.
+        let intersect = AB.intersection(BC)
+        if (intersect.hasIntersection) {
+            this.#B = intersect.point
+        } else {
+            this.#isValid = false
+            return this
+        }
+
+        intersect = BC.intersection(AC)
+        if (intersect.hasIntersection) {
+            this.#C = intersect.point
+        } else {
+            this.#isValid = false
+            return this
+        }
+
+        intersect = AC.intersection(AB)
+        if (intersect.hasIntersection) {
+            this.#A = intersect.point
+        } else {
+            this.#isValid = false
+            return this
+        }
+
+        // reset the remarquables lines.
+        this.reset()
+
+        // Force the use of the given lines.
+        this.#lines = {AB, AC, BC}
+
+        return this
+
+    }
+
+    fromPoints(A: Point, B: Point, C: Point): this {
+        // We have three points.
+        this.#A = A.clone()
+        this.#B = B.clone()
+        this.#C = C.clone()
+
+        this.reset()
+
+        return this
+    }
+
+    getAngle(name: 'A' | 'B' | 'C'): number {
+        const a = this.BC.norm
+        const b = this.AC.norm
+        const c = this.AB.norm
+
+        if (name === 'A') {
+            return this.#cosThm(a, b, c)
+        }
+
+        if (name === 'C') {
+            return this.#cosThm(c, b, a)
+        }
+
+        return this.#cosThm(b, a, c)
+    }
+
+
+    getBisectors(internal = true): { 'A': Line, 'B': Line, 'C': Line, 'intersection': Point | null } {
+
+        if (!this.#remarquables.bisectors) {
+            const A = this.#calculateBisectors('A', internal)
+            const B = this.#calculateBisectors('B', internal)
+            const C = this.#calculateBisectors('C', internal)
+
+            const intersection = A.intersection(B).point
+            this.#remarquables.bisectors = {A, B, C, intersection}
+        }
+
+        return this.#remarquables.bisectors
+    }
+
+    getHeights(): { 'A': Line, 'B': Line, 'C': Line, 'intersection': Point | null } {
+
+        if (!this.#remarquables.heights) {
+            const A = new Line().fromPointAndNormal(this.#A, new Vector(this.#B, this.#C))
+            const B = new Line().fromPointAndNormal(this.#B, new Vector(this.#A, this.#C))
+            const C = new Line().fromPointAndNormal(this.#C, new Vector(this.#A, this.#B))
+
+            const intersection = A.intersection(B).point
+            this.#remarquables.heights = {A, B, C, intersection}
+        }
+
+        return this.#remarquables.heights
+    }
+
+    getMedians(): { 'A': Line, 'B': Line, 'C': Line, 'intersection': Point | null } {
+        const middles = this.getMiddles()
+
+        if (!this.#remarquables.medians) {
+            const A = new Line().fromPoints(this.#A, middles.BC)
+            const B = new Line().fromPoints(this.#B, middles.AC)
+            const C = new Line().fromPoints(this.#C, middles.AB)
+
+            const intersection = A.intersection(B).point
+            this.#remarquables.medians = {A, B, C, intersection}
+        }
+
+        return this.#remarquables.medians
+    }
+
+    getMediators(): { 'a': Line, 'b': Line, 'c': Line, 'intersection': Point | null } {
+        const middles = this.getMiddles()
+
+        if (!this.#remarquables.mediators) {
+            const a = new Line().fromPointAndNormal(middles.BC, new Vector(this.#B, this.#C))
+            const b = new Line().fromPointAndNormal(middles.AC, new Vector(this.#A, this.#C))
+            const c = new Line().fromPointAndNormal(middles.AB, new Vector(this.#A, this.#B))
+
+            const intersection = a.intersection(b).point
+            this.#remarquables.mediators = {a, b, c, intersection}
+        }
+
+        return this.#remarquables.mediators
+    }
+
+    getMiddles() {
+        return {
+            'AB': new Point().middleOf(this.#A, this.#B),
+            'AC': new Point().middleOf(this.#A, this.#C),
+            'BC': new Point().middleOf(this.#B, this.#C)
+        }
+    }
+
+    getPoints(): Point[] {
+        return [this.A, this.B, this.C]
+    }
+
+    getSortedPoints(): Point[] {
+        return this.getPoints().sort((a, b) => {
+            return a.x.value === b.x.value
+                ? a.y.value - b.y.value
+                : a.x.value - b.x.value
+        })
+    }
+
+    isEqual(T: Triangle): boolean {
+        if (!this.#isValid || !T.isValid) return false
+
+        // TODO: compare points in a particular order.
+        const tri1 = this.getSortedPoints()
+        const tri2 = T.getSortedPoints()
+
+        return tri1.every((_, index) => tri1[index].isEqual(tri2[index]))
+
+    }
+
+    isEquilateral(): boolean {
+        if (!this.#isValid) return false
+
+        const dAB = this.AB.normSquare.value
+        const dBC = this.BC.normSquare.value
+        const dAC = this.AC.normSquare.value
+
+        return (dAB === dBC) && (dAB === dAC)
+    }
+
+    isIsocele(): boolean {
+        if (!this.#isValid) return false
+
+        const dAB = this.AB.normSquare.value
+        const dBC = this.BC.normSquare.value
+        const dAC = this.AC.normSquare.value
+
+        return dAB === dBC ||
+            dAB === dAC ||
+            dBC === dAC
+    }
+
+    isRectangle(): boolean {
+        if (!this.#isValid) return false
+
+        return this.AB.isNormalTo(this.BC) ||
+            this.AB.isNormalTo(this.AC) ||
+            this.BC.isNormalTo(this.AC)
+    }
+
+    get isValid(): boolean {
+        return this.#isValid
+    }
+
+    set isValid(value: boolean) {
+        this.#isValid = value
+    }
+
+    get lines(): Record<TRIANGLE_SIDES, Line> {
+        if (this.#lines === null) {
+            this.#lines = {
+                'AB': new Line(this.#A, this.#B),
+                'BC': new Line(this.#B, this.#C),
+                'AC': new Line(this.#A, this.#C)
+            }
+        }
+
+        return this.#lines
+    }
+
+    medianA(): Line {
+        return this.getMedians().A
+    }
+
+    medianB(): Line {
+        return this.getMedians().B
+    }
+
+    medianC(): Line {
+        return this.getMedians().C
+    }
+
+    get remarquables(): remarquableLines | null {
+        return this.#remarquables
+    }
+
+    public reset(): this {
+        // Check if the triangle is valid
+        // the three points must NOT be aligned.
+        this.#isValid = !this.AB.isColinearTo(this.AC)
+
+        this.#lines = null
+        this.#remarquables = {
+            mediators: null,
+            medians: null,
+            heights: null,
+            externalBisectors: null,
+            bisectors: null
+        }
+
+        return this
+    }
+
+    #calculateBisectors(pt: string, internal = true): Line {
+        const tlines = this.lines
+        let d1: Vector = new Vector()
+        let d2: Vector = new Vector()
+        let P: Point = new Point()
+
+        if (pt === 'A') {
+            P = this.A.clone()
+            d1 = tlines.AB.clone().d
+            d2 = tlines.AC.clone().d
+        } else if (pt === 'B') {
+            P = this.B.clone()
+            d1 = tlines.AB.clone().d.opposite()
+            d2 = tlines.BC.clone().d
+        } else if (pt === 'C') {
+            P = this.C.clone()
+            d1 = tlines.BC.clone().d.opposite()
+            d2 = tlines.AC.clone().d.opposite()
+        }
+
+        if (d1 === undefined || d2 === undefined) {
+            throw new Error(`The point ${pt} does not exist`)
+        }
+
+        const director = internal
+            ? d1.unit().add(d2.unit())
+            : d1.unit().subtract(d2.unit())
+
+        return new Line().fromPointAndDirection(P, director)
+    }
+
+    #cosThm(opposite: number, adjacent1: number, adjacent2: number): number {
+        const ratio = ((adjacent1 ** 2 + adjacent2 ** 2) - opposite ** 2) / (2 * adjacent1 * adjacent2)
+
+        return this.#radians
+            ? Math.acos(ratio)
+            : Numeric.numberCorrection(Math.acos(ratio) * 180 / Math.PI)
+    }
+
+    /**
+     * Get the Point class for the given name
+     * @param ptName
+     */
+    #getPointByName = (ptName: string): Point => {
+        switch (ptName.toUpperCase()) {
+            case 'A':
+                return this.#A
+            case 'B':
+                return this.#B
+            case 'C':
+                return this.#C
+        }
+
+        // Something went wrong ! Return the first point
+        return this.#A
+    }
+
+    /**
+     * Get the vector for the segment given by name.
+     * @param ptName1
+     * @param ptName2
+     */
+    #getSegment = (ptName1: string, ptName2: string): Vector => {
+        return new Vector(
+            this.#getPointByName(ptName1),
+            this.#getPointByName(ptName2)
+        )
+    }
+
+}

package/src/geometry/vector.ts

@@ -0,0 +1,225 @@
+/**
+ * Vector2D module contains everything necessary to handle 2d vectors.
+ * @module Vector
+ */
+import type {InputValue, IPiMathObject} from "../pimath.interface"
+import {Fraction} from "../coefficients"
+import {Numeric} from "../numeric"
+import {areVectorsColinears, areVectorsEquals, dotProduct} from "./geomMath"
+import {TupleN} from "./TupleN"
+import {type Point} from "./point"
+
+export class Vector extends TupleN implements IPiMathObject<Vector> {
+    constructor(...values: (Vector | Point)[] | InputValue<Fraction>[]) {
+        super()
+
+        if (values.length > 0) {
+            this.parse(...values)
+        }
+
+        return this
+    };
+
+    // ------------------------------------------
+    // Getter and setter
+
+    public parse(...values: (Vector | Point)[] | InputValue<Fraction>[]): this {
+        if (values.length === 0) {
+            throw new Error(`Invalid value`)
+        }
+
+        if (values.length === 1) {
+            if (values[0] instanceof TupleN) {
+                this.array = values[0].copy()
+                return this
+            }
+
+            if (typeof values[0] === 'string') {
+                return this.fromString(values[0])
+            }
+
+            throw new Error(`Invalid value`)
+        }
+
+        // Two values are given
+        if (values.length === 2) {
+            const [A, B] = values
+
+            // The two values are vectors
+            if (A instanceof TupleN && B instanceof TupleN) {
+                if (A.dimension !== B.dimension) {
+                    throw new Error('Vectors must have the same dimension')
+                }
+
+                this.array = B.array.map((x, index) => x.clone().subtract(A.array[index]))
+                return this
+            }
+        }
+
+        // Two ore more values as number, string, fraction...
+        this.array = values.map(x => new Fraction(x as InputValue<Fraction>))
+        return this
+    }
+
+    public clone(): Vector {
+        return new Vector(...this.copy())
+    }
+
+    get tex(): string {
+        return `\\begin{pmatrix} ${this.array.map(x => x.tex).join(' \\\\ ')} \\end{pmatrix}`
+    }
+
+    get display(): string {
+        return `((${this.array.map(x => x.display).join(',')}))`
+    }
+
+    static asDisplay(...values: string[]): string {
+        return `((${values.join(',')}))`
+    }
+
+    static asTex(...values: string[]): string {
+        return `\\begin{pmatrix} ${values.join(' \\\\ ')} \\end{pmatrix}`
+    }
+
+    add = (V: Vector): this => {
+        this.array.forEach((x, index) => x.add(V.array[index]))
+        return this
+    }
+
+    angle = (V: Vector, sharp?: boolean, radian?: boolean): number => {
+
+        let scalar = this.dot(V).value
+        if (sharp) {
+            scalar = Math.abs(scalar)
+        }
+
+        const toDegree = radian ? 1 : 180 / Math.PI
+
+        return toDegree * Math.acos(scalar / (this.norm * V.norm))
+    }
+
+    cross(value: Vector): Vector {
+        if (this.dimension !== 3 || value.dimension !== 3) {
+            throw new Error('Cross product can only be determined in 3D')
+        }
+
+        return new Vector(
+            this.y.clone().multiply(value.z).subtract(this.z.clone().multiply(value.y)),
+            this.z.clone().multiply(value.x).subtract(this.x.clone().multiply(value.z)),
+            this.x.clone().multiply(value.y).subtract(this.y.clone().multiply(value.x))
+        )
+    }
+
+    // ------------------------------------------
+    // Creation / parsing functions
+
+    divideByScalar = (k: InputValue<Fraction>): this => {
+        return this.multiplyByScalar(new Fraction(k).inverse())
+    }
+
+    dot = (V: Vector |Point): Fraction => {
+        return dotProduct(this, V)
+    }
+
+    override fromString(value: string): this {
+        if (value.startsWith('((') && value.endsWith('))')) {
+            return super.fromString(value.slice(1, -1))
+        }
+
+        return super.fromString(value)
+    }
+
+    isColinearTo = (v: Vector): boolean => {
+        return areVectorsColinears(this, v)
+    }
+
+    isEqual = (v: Vector): boolean => {
+        return areVectorsEquals(this, v)
+    }
+
+    isNormalTo = (v: Vector): boolean => {
+        return this.dot(v).isZero()
+    }
+
+    // ------------------------------------------
+    get isNull(): boolean {
+        return this.array.every(x => x.isZero())
+    }
+
+    isOne(): boolean {
+        return this.array.every((x, index) => index === 0 ? x.isOne() : x.isZero())
+    }
+
+    isZero(): boolean {
+        return this.array.every(x => x.isZero())
+    }
+
+    multiplyByScalar = (k: InputValue<Fraction>): this => {
+        const scalar = new Fraction(k)
+        this.array.forEach(x => x.multiply(scalar))
+        return this
+    }
+
+    get norm(): number {
+        return Math.sqrt(this.normSquare.value)
+    }
+
+    get normSquare(): Fraction {
+        // Get the norm square of the vector
+        return this.array.reduce((acc, x) => acc.add(x.clone().pow(2)), new Fraction(0))
+    }
+
+    normal = (): this => {
+        if (this.dimension >= 3) {
+            throw new Error('Normal vector can only be determined in 2D')
+        }
+
+        const x = this.x.clone().opposite()
+        const y = this.y.clone()
+
+        this.array[0] = y
+        this.array[1] = x
+        return this
+    }
+
+    one = (): this => {
+        this.zero()
+        this.x.one()
+        return this
+    }
+
+    opposite = (): this => {
+        this.array.forEach(x => x.opposite())
+        return this
+    }
+
+    simplify = (): this => {
+        const lcm = Numeric.lcm(...this.array.map(x => x.denominator))
+        const gcd = Numeric.gcd(...this.array.map(x => x.numerator))
+
+        this.multiplyByScalar(new Fraction(lcm, gcd))
+
+        if(this.x.isNegative()) this.opposite()
+
+        return this
+    }
+
+    subtract = (V: Vector): this => {
+        return this.add(V.clone().opposite())
+    }
+
+    translate(...values: Fraction[]): this {
+        this.array.forEach((x, index) => x.add(values[index]))
+        return this
+    }
+
+    unit = (): this => {
+        const norm = this.norm
+        if (norm === 0) {
+            return this
+        }
+
+        return this.divideByScalar(norm)
+    }
+
+}