pimath 0.1.39 → 0.1.40

package/src/geometry/triangle.ts

@@ -0,0 +1,354 @@
+import { Fraction } from "../coefficients/fraction"
+import { Line } from "./line"
+import { Vector } from "./vector"
+import { Point } from "./point"
+import type {remarquableLines} from "../pimath.interface"
+
+export class Triangle {
+    #A: Point = new Point()
+    #B: Point = new Point()
+    #C: Point = new Point()
+    #lines: { 'AB': Line, 'AC': Line, 'BC': Line } = {
+        'AB': new Line(),
+        'AC': new Line(),
+        'BC': new Line()
+    }
+    #middles: { 'AB': Point, 'AC': Point, 'BC': Point } = {
+        'AB': new Point(),
+        'AC': new Point(),
+        'BC': new Point()
+    }
+    #remarquables: remarquableLines | null = null
+
+    constructor(...values: unknown[]) {
+
+        if (values.length > 0) {
+            this.parse(...values)
+        }
+
+        return this
+    }
+
+    // ------------------------------------------
+    // Getter and setters
+    // ------------------------------------------
+
+    get A(): Point {
+        return this.#A
+    }
+
+    get B(): Point {
+        return this.#B
+    }
+
+    get C(): Point {
+        return this.#C
+    }
+
+    get AB(): Vector {
+        return this.#getSegment('A', 'B')
+    }
+
+    get BA(): Vector {
+        return this.#getSegment('B', 'A')
+    }
+
+    get BC(): Vector {
+        return this.#getSegment('B', 'C')
+    }
+
+    get CB(): Vector {
+        return this.#getSegment('C', 'B')
+    }
+
+    get AC(): Vector {
+        return this.#getSegment('A', 'C')
+    }
+
+    get CA(): Vector {
+        return this.#getSegment('C', 'A')
+    }
+
+    get isRectangle(): boolean {
+        if (this.AB.isNormalTo(this.BC)) {
+            return true
+        }
+        if (this.AB.isNormalTo(this.AC)) {
+            return true
+        }
+        if (this.BC.isNormalTo(this.AC)) {
+            return true
+        }
+
+        return false
+    }
+
+    get isEquilateral(): boolean {
+        return this.AB.normSquare.isEqual(this.BC.normSquare) &&
+            this.AB.normSquare.isEqual(this.AC.normSquare)
+    }
+
+    get isIsocele(): boolean {
+        return this.AB.normSquare.isEqual(this.BC.normSquare) ||
+            this.AB.normSquare.isEqual(this.AC.normSquare) ||
+            this.BC.normSquare.isEqual(this.AC.normSquare)
+    }
+
+    get lines(): { 'AB': Line, 'BC': Line, 'AC': Line } {
+        return this.#lines
+    }
+
+    get remarquables(): remarquableLines | null {
+        return this.#remarquables
+    }
+
+    // ------------------------------------------
+    // Creation / parsing functions
+    // ------------------------------------------
+
+    /**
+     * Parse values to a triangle. Supported formats:
+     * Vector2D, Vector2D, Vector2D
+     * x1, y1, x2, y2, x3, y3
+     * @param values
+     */
+    parse = (...values: unknown[]): Triangle => {
+        if (values.length === 6) {
+            // Check if all values are number or fractions.
+            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.parse(
+                new Vector(v[0], v[1]),
+                new Vector(v[2], v[3]),
+                new Vector(v[4], v[5]),
+            )
+        } else 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.
+                return this.parse(
+                    ...values.map((x) => {
+                        return new Line(x)
+                    })
+                )
+            } else if (values.every((x: unknown) => x instanceof Line)) {
+                // We have three lines
+                const AB: Line = (values[0]).clone()
+                const BC: Line = (values[1]).clone()
+                const AC: Line = (values[2]).clone()
+                this.#lines = { AB, BC, AC }
+
+                // Get the intersection points -> build the triangle using these intersection points.
+                let intersect = AB.intersection(BC)
+                if (intersect.hasIntersection) {
+                    this.#B = intersect.point.clone()
+                } else {
+                    throw new Error('Lines do not intersect !')
+                }
+
+                intersect = BC.intersection(AC)
+                if (intersect.hasIntersection) {
+                    this.#C = intersect.point.clone()
+                } else {
+                    throw new Error('Lines do not intersect !')
+                }
+
+                intersect = AC.intersection(AB)
+                if (intersect.hasIntersection) {
+                    this.#A = intersect.point.clone()
+                } else {
+                    throw new Error('Lines do not intersect !')
+                }
+
+            } else if (values.every((x: unknown) => (x instanceof Point))) {
+                // We have three points.
+                this.#A = (values[0]).clone()
+                this.#B = (values[1]).clone()
+                this.#C = (values[2]).clone()
+                this.#lines = {
+                    'AB': new Line(this.#A, this.#B),
+                    'BC': new Line(this.#B, this.#C),
+                    'AC': new Line(this.#A, this.#C)
+                }
+            }
+        } else if (values.length === 1) {
+            if (values[0] instanceof Triangle) {
+                return values[0].clone()
+            }
+        }
+
+        this.#updateTriangle()
+        return this
+    }
+
+    /**
+     * Clone the Triangle class
+     */
+    clone = (): Triangle => {
+        return new Triangle(
+            this.#A.clone(),
+            this.#B.clone(),
+            this.#C.clone()
+        )
+    }
+
+
+    // ------------------------------------------
+    // Triangle operations and properties
+    // ------------------------------------------
+
+    /**
+     * Generate the Line object for the three segments of the triangle
+     */
+    #updateTriangle = () => {
+        this.#A.asPoint = true
+        this.#B.asPoint = true
+        this.#C.asPoint = true
+
+        this.#middles = {
+            'AB': new Point().middleOf(this.#A, this.#B),
+            'AC': new Point().middleOf(this.#A, this.#C),
+            'BC': new Point().middleOf(this.#B, this.#C)
+        }
+
+        this.#remarquables = this.#calculateRemarquableLines()
+    }
+
+
+    /**
+     * Get the Vector2D 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)
+        )
+    }
+
+    #calculateRemarquableLines = (): remarquableLines => {
+
+        const medians = {
+            'A': new Line().fromPoints(this.#A, this.#middles.BC),
+            'B': new Line().fromPoints(this.#B, this.#middles.AC),
+            'C': new Line().fromPoints(this.#C, this.#middles.AB),
+            'intersection': null
+        }
+
+        const mediators = {
+            'AB': new Line().fromPointAndNormal(this.#middles.AB, new Vector(this.#A, this.#B).normal()),
+            'AC': new Line().fromPointAndNormal(this.#middles.AC, new Vector(this.#A, this.#C).normal()),
+            'BC': new Line().fromPointAndNormal(this.#middles.BC, new Vector(this.#B, this.#C).normal()),
+            'intersection': null
+        }
+
+        const heights = {
+            'A': new Line().fromPointAndNormal(this.#A, new Vector(this.#B, this.#C).normal()),
+            'B': new Line().fromPointAndNormal(this.#B, new Vector(this.#A, this.#C).normal()),
+            'C': new Line().fromPointAndNormal(this.#C, new Vector(this.#A, this.#B).normal()),
+            'intersection': null
+        }
+
+        const bA = this.#calculateBisectors('A'),
+            bB = this.#calculateBisectors('B'),
+            bC = this.#calculateBisectors('C')
+
+        const bisectors = {
+            'A': bA.internal,
+            'B': bB.internal,
+            'C': bB.internal,
+            'intersection': null
+        }
+
+        const externalBisectors = {
+            'A': bA.external,
+            'B': bB.external,
+            'C': bC.external,
+            'intersection': null
+        }
+
+        const remarquables: remarquableLines = {
+            medians,
+            mediators,
+            heights,
+            bisectors,
+            externalBisectors
+        }
+
+        // As it's a triangle, we assume the lines are intersecting and aren't parallel or superposed.
+        remarquables.medians.intersection = remarquables.medians.A.intersection(remarquables.medians.B).point
+        remarquables.mediators.intersection = remarquables.mediators.AB.intersection(remarquables.mediators.BC).point
+        remarquables.heights.intersection = remarquables.heights.A.intersection(remarquables.heights.B).point
+        remarquables.bisectors.intersection = remarquables.bisectors.A.intersection(remarquables.bisectors.B).point
+
+        // Everything was calculated for the remarquable lines.
+        return remarquables
+    }
+
+    #calculateBisectors = (pt: string): { internal: Line, external: Line } => {
+        const tlines = this.lines
+        let d1, d2
+
+        if (pt === 'A') {
+            d1 = tlines.AB
+            d2 = tlines.AC
+        } else if (pt === 'B') {
+            d1 = tlines.AB
+            d2 = tlines.BC
+        } else if (pt === 'C') {
+            d1 = tlines.BC
+            d2 = tlines.AC
+        }
+
+        if (d1 === undefined || d2 === undefined) {
+            throw new Error(`The point ${pt} does not exist`)
+        }
+
+        const d1n = d1.n.simplify().norm
+        const d2n = d2.n.simplify().norm
+        const d1Equ = d1.getEquation().multiply(d2n)
+        const d2Equ = d2.getEquation().multiply(d1n)
+
+        const b1: Line = new Line(d1Equ.clone().subtract(d2Equ).simplify())
+        const b2: Line = new Line(d2Equ.clone().subtract(d1Equ).simplify())
+
+        // Must determine which bisectors is in the triangle
+        if (pt === 'A') {
+            return b1.hitSegment(this.B, this.C) ? { internal: b1, external: b2 } : { internal: b2, external: b1 }
+        }
+        if (pt === 'B') {
+            return b1.hitSegment(this.A, this.C) ? { internal: b1, external: b2 } : { internal: b2, external: b1 }
+        }
+        if (pt === 'C') {
+            return b1.hitSegment(this.B, this.A) ? { internal: b1, external: b2 } : { internal: b2, external: b1 }
+        }
+
+        // Default returns the first bisector
+        return { internal: b1, external: b2 }
+    }
+}

package/src/geometry/vector.ts

@@ -0,0 +1,341 @@
+/**
+ * Vector2D module contains everything necessary to handle 2d vectors.
+ * @module Vector
+ */
+import type { InputValue, IPiMathObject } from "../pimath.interface"
+import { Fraction } from "../coefficients/fraction"
+import { Numeric } from "../numeric"
+import { areVectorsColinears, areVectorsEquals, dotProduct } from "./geomMath"
+
+export class Vector implements
+    IPiMathObject<Vector> {
+    #array: Fraction[] = []
+    #asPoint = false
+
+    constructor(...values: Vector[] | InputValue<Fraction>[]) {
+        if (values.length > 0) {
+            this.parse(...values)
+        }
+    };
+
+    // ------------------------------------------
+    // Getter and setter
+    // ------------------------------------------
+    get array(): Fraction[] {
+        return this.#array
+    }
+
+    set array(value: Fraction[]) {
+        this.#array = value
+    }
+
+    get x(): Fraction {
+        return this.#array[0]
+    }
+
+    set x(value: Fraction | number | string) {
+        this.#array[0] = new Fraction(value)
+    }
+
+    get y(): Fraction {
+        return this.#array[1]
+    }
+
+    set y(value: Fraction | number | string) {
+        this.#array[1] = new Fraction(value)
+    }
+
+    get z(): Fraction {
+        if (this.dimension < 3) { throw new Error('Vector is not 3D') }
+        return this.#array[2]
+    }
+
+    set z(value: Fraction | number | string) {
+        if (this.dimension < 3) { throw new Error('Vector is not 3D') }
+        this.#array[2] = new Fraction(value)
+    }
+
+    get asPoint(): boolean {
+        return this.#asPoint
+    }
+
+    set asPoint(value: boolean) {
+        this.#asPoint = 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))
+    }
+
+    get norm(): number {
+        return Math.sqrt(this.normSquare.value)
+    }
+
+    get tex(): string {
+        if (this.#asPoint) {
+            return `\\left(${this.array.map(x => x.tex).join(';')}\\right)`
+        }
+
+        return `\\begin{pmatrix} ${this.array.map(x => x.tex).join(' \\\\ ')} \\end{pmatrix}`
+    }
+
+    get display(): string {
+        if (this.#asPoint) {
+            return `(${this.array.map(x => x.display).join(';')})`
+        }
+
+        return `((${this.array.map(x => x.display).join(',')}))`
+    }
+
+    setDimension(value = 2): this{
+        if (value < 2) {
+            throw new Error('Dimension must be at least 2')
+        }
+
+        if (value < this.dimension) {
+            this.#array = this.#array.slice(0, value)
+        } else if(value > this.dimension) {
+            for(let i = this.dimension; i < value; i++) {
+                this.#array.push(new Fraction(0))
+            }
+        }
+
+        return this
+    }
+    get dimension(): number {
+        return this.array.length
+    }
+
+    // ------------------------------------------
+    // Creation / parsing functions
+    // ------------------------------------------
+    get isNull(): boolean {
+        return this.array.every(x => x.isZero())
+    }
+
+    static asTex(...values: string[]): string {
+        return `\\begin{pmatrix} ${values.join(' \\\\ ')} \\end{pmatrix}`
+    }
+    static asDisplay(...values: string[]): string {
+        return `((${values.join(',')}))`
+    }
+
+    public defineAsPoint(value?: boolean): this {
+        this.#asPoint = value !== false
+        return this
+    }
+    public parse(...values: Vector[] | InputValue<Fraction>[]): this {
+        if (values.length === 0) {
+            throw new Error(`Invalid value`)
+        }
+
+        if (values.length === 1) {
+            if (values[0] instanceof Vector) {
+                return values[0].clone() as this
+            } else if (typeof values[0] === 'string') {
+                return this.fromString(values[0])
+            } else {
+                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 Vector && B instanceof Vector) {
+                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 {
+        const V = new Vector()
+        V.array = this.copy()
+        V.asPoint = this.asPoint
+        return V
+    }
+
+    public copy(): Fraction[] {
+        return this.#array.map(x => x.clone())
+    }
+
+    zero = (): this => {
+        this.#array.forEach(x => x.zero())
+        return this
+    }
+
+    one = (): this => {
+        this.zero()
+        this.x.one()
+        return this
+    }
+
+    opposite = (): this => {
+        this.#array.forEach(x => x.opposite())
+        return this
+    }
+
+    add = (V: Vector): this => {
+        this.#array.forEach((x, index) => x.add(V.array[index]))
+        return this
+    }
+
+    subtract = (V: Vector): this => {
+        return this.add(V.clone().opposite())
+    }
+
+    unit = (): this => {
+        const norm = this.norm
+        if (norm === 0) {
+            return this
+        }
+
+        return this.divideByScalar(norm)
+    }
+
+    middleOf(V1: Vector, V2: Vector): this {
+        if (V1.dimension !== V2.dimension) { throw new Error('Vectors must be the same dimension') }
+
+        this.array = []
+        V1.array.forEach((x, index) => {
+            this.array.push(x.clone().add(V2.array[index]).divide(2))
+        })
+
+        return this
+    }
+
+    translate(...values: Fraction[]): this {
+        this.array.forEach((x, index) => x.add(values[index]))
+        return this
+    }
+
+
+    dot = (V: Vector): Fraction => {
+        return dotProduct(this, V)
+    }
+
+    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))
+        )
+    }
+
+    normal = (): this => {
+        if (this.dimension >= 3) { throw new Error('Normal vector can only be determined in 2D') }
+
+        const x = this.x.clone().opposite(),
+            y = this.y.clone()
+        this.#array[0] = y
+        this.#array[1] = x
+        return this
+    }
+
+    isZero(): boolean {
+        return this.array.every(x => x.isZero())
+    }
+    isOne(): boolean {
+        return this.array.every((x, index) => index === 0 ? x.isOne() : x.isZero())
+    }
+
+    isEqual = (v: Vector): boolean => {
+        return areVectorsEquals(this, v)
+    }
+
+    isColinearTo = (v: Vector): boolean => {
+        return areVectorsColinears(this, v)
+    }
+
+    isNormalTo = (v: Vector): boolean => {
+        return this.dot(v).isZero()
+    }
+
+    multiplyByScalar = (k: InputValue<Fraction>): this => {
+        const scalar = new Fraction(k)
+        this.array.forEach(x => x.multiply(scalar))
+        return this
+    }
+
+    divideByScalar = (k: InputValue<Fraction>): this => {
+        return this.multiplyByScalar(new Fraction(k).inverse())
+    }
+
+    simplify = (): this => {
+        // Multiply by the lcm of denominators.
+        return this
+            .multiplyByScalar(
+                Numeric.lcm(...this.array.map(x => x.denominator))
+            )
+            .divideByScalar(
+                Numeric.gcd(...this.array.map(x => x.numerator))
+            ).
+            multiplyByScalar(
+                this.x.isNegative() ? -1 : 1
+            )
+    }
+
+    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))
+    }
+
+
+    fromString = (value: string): this => {
+        // Remove the first letter if it's a parenthesis.
+        if (value.startsWith('(')) {
+            value = value.substring(1)
+        }
+
+        // Remove the last letter if it's a parenthesis.
+        if (value.endsWith(')')) {
+            value = value.substring(0, value.length - 1)
+        }
+
+        // Split comma, semi colon or single space.
+        const components = value.split(/[,;\s]/g)
+            .filter((v) => v.trim() !== '')
+
+        // there must be at least two components.
+        if (components.length < 2) {
+            return this
+        }
+
+        // Validate the fraction values.
+        this.#array = components.map(x => new Fraction(x))
+        return this
+    }
+
+    distanceTo(item: Vector): { value: number, fraction: Fraction, tex: string } {
+        const V = new Vector(this, item)
+
+        return {
+            value: V.norm,
+            fraction: V.normSquare,
+            tex: V.tex
+        }
+    }
+}