pimath 0.0.129 → 0.0.130

package/lib/maths/geometry/point.ts

@@ -0,0 +1,215 @@
+/**
+ * Vector module contains everything necessary to handle 2d or 3d vectors.
+ * @module Vector
+ */
+import {Line} from "./line";
+import {Vector} from "./vector";
+import {Fraction} from "../coefficients/fraction";
+
+/**
+ * Helper class - a way to identify an object {x: number, y: number}
+ */
+class PointXY {
+    x: number
+    y: number
+}
+
+export class Point {
+    private _x: Fraction;   // 1st component
+    private _y: Fraction;   // 2nd component
+    private _exist: Boolean;
+
+    constructor(...values: unknown[]) {
+        this._x = new Fraction().zero();
+        this._y = new Fraction().zero();
+
+        if (values !== undefined) {
+            this.parse(...values);
+        }
+
+        return this
+    };
+
+    // ------------------------------------------
+    // Getter and setter
+    // ------------------------------------------
+    get x(): Fraction {
+        return this._x;
+    }
+
+    set x(value: Fraction) {
+        this._x = value;
+    }
+
+    get y(): Fraction {
+        return this._y;
+    }
+
+    set y(value: Fraction) {
+        this._y = value;
+    }
+
+    get tex(): string {
+        let pts = [];
+
+        pts.push(this._x.tex);
+        pts.push(this._y.tex);
+
+        return `\\left(${pts.join(';')}\\right)`
+    }
+
+    get display(): string {
+        let pts = [];
+
+        pts.push(this._x.tex);
+        pts.push(this._y.tex);
+
+        return `(${pts.join(';')})`
+    }
+
+    get asVector(): Vector {
+        return new Vector(this.x, this.y)
+    }
+
+    // ------------------------------------------
+    // Creation / parsing functions
+
+    get key(): string {
+        return `${this.x.display};${this.y.display}`
+    }
+
+    // ------------------------------------------
+    static pmatrix = (a: any, b: any, c?: any): string => {
+        if (c === undefined) {
+            return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\end{pmatrix}`;
+        } else {
+            return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\\\ ${c.tex ? c.tex : c} \\end{pmatrix}`;
+        }
+    };
+
+    // ------------------------------------------
+    parse = (...values: unknown[]): Point => {
+        // Initialize the value.
+        this.zero();
+
+        // Nothing is given
+        if (values.length === 0) {
+            return this;
+        }
+
+        // One element is given - might be already a point !
+        if (values.length === 1) {
+            // it's already a point - clone it
+            if (values[0] instanceof Point) {
+                this._x = values[0].x.clone()
+                this._y = values[0].y.clone()
+                return this
+            }
+
+            // Value is given as string, comma separated.
+            if (typeof values[0] === 'string') {
+                let xy = values[0].split(',')
+                if (xy.length === 2) {
+                    this._x = new Fraction(xy[0]).reduce()
+                    this._y = new Fraction(xy[1]).reduce()
+                    return this
+                }
+            }
+
+            // Value given as an object with {x: value, y: value}
+            if (values[0] instanceof PointXY) {
+                this._x = new Fraction(values[0].x).reduce()
+                this._y = new Fraction(values[0].y).reduce()
+                return this
+            } else {
+                return this.zero()
+            }
+        }
+
+        if (values.length === 2) {
+            this._x = new Fraction(values[0]).reduce()
+            this._y = new Fraction(values[1]).reduce()
+            return this
+        }
+
+        return this;
+    };
+
+    clone = (): Point => {
+        this._x = this._x.clone()
+        this._y = this._y.clone()
+
+        return this
+    }
+
+    zero = (): Point => {
+        this._x = new Fraction(null);
+        this._y = new Fraction(null);
+        return this;
+    }
+
+    origin = (): Point => {
+        this.zero();
+        return this;
+    }
+    // ------------------------------------------
+    // Display functions
+
+    middleOf = (P1: Point, P2: Point): Point => {
+        this._x = P1.x.clone().add(P2.x).divide(2);
+        this._y = P1.y.clone().add(P2.y).divide(2);
+
+        return this;
+    }
+    // ------------------------------------------
+    // Mathematical operations
+    // ------------------------------------------
+
+    // ------------------------------------------
+    // Vector functions
+    // ------------------------------------------
+
+    // ------------------------------------------
+    // Static functions
+
+    translate = (value: { x: number | Fraction, y: number | Fraction }): Point => {
+        this._x = this._x.add(value.x)
+        this._y = this._y.add(value.y)
+        return this
+    }
+
+    // ------------------------------------------
+    texValues = (numberOfDigits: number): string => {
+        let pts = [];
+
+        pts.push(this._x.value.toFixed(numberOfDigits === undefined ? 2 : numberOfDigits));
+        pts.push(this._y.value.toFixed(numberOfDigits === undefined ? 2 : numberOfDigits));
+
+        return `\\left(${pts.join(';')}\\right)`
+    }
+
+    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{\\frac{ ${V.normSquare.numerator} }{ ${V.normSquare.denominator} }}`
+        }
+        return {value, fraction, tex}
+    }
+
+    isInListOfPoints = (list: Point[]): boolean => {
+        const keyList = list.map(x => x.key)
+
+        return keyList.includes(this.key)
+    }
+
+    isEqual = (pt: Point): boolean => {
+        return this.x.isEqual(pt.x) && this.y.isEqual(pt.y)
+    }
+}

package/lib/maths/geometry/triangle.ts

@@ -0,0 +1,368 @@
+import {Point} from "./point";
+import {Fraction} from "../coefficients/fraction";
+import {Vector} from "./vector";
+import {Line} from "./line";
+import {Equation} from "../algebra/equation";
+
+export interface remarquableLines {
+    'medians': {
+        'A': Line,
+        'B': Line,
+        'C': Line,
+        'intersection': Point
+    },
+    'mediators': {
+        'AB': Line,
+        'AC': Line,
+        'BC': Line,
+        'intersection': Point
+    },
+    'heights': {
+        'A': Line,
+        'B': Line,
+        'C': Line,
+        'intersection': Point
+    },
+    'bisectors': {
+        'A': Line,
+        'B': Line,
+        'C': Line,
+        'intersection': Point
+    },
+    externalBisectors: {
+        'A': Line,
+        'B': Line,
+        'C': Line,
+        'intersection': Point
+    }
+}
+
+export class Triangle {
+    private _A: Point;
+    private _B: Point;
+    private _C: Point;
+    private _lines: {
+        'AB': Line,
+        'AC': Line,
+        'BC': Line
+    };
+    private _middles: {
+        'AB': Point,
+        'AC': Point,
+        'BC': Point
+    };
+    private _remarquables: remarquableLines;
+
+
+    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 {
+        return this._remarquables;
+    }
+
+    // ------------------------------------------
+    // Creation / parsing functions
+    // ------------------------------------------
+
+    /**
+     * Parse values to a triangle. Supported formats:
+     * Point, Point, Point
+     * x1, y1, x2, y2, x3, y3
+     * TODO: Something else ?
+     * @param values
+     */
+    parse = (...values: any): Triangle => {
+        if (values.length === 6) {
+            // Check if all values are number or fractions.
+            let v = values.map((x: any) => new Fraction(x));
+            return this.parse(
+                new Point(v[0], v[1]),
+                new Point(v[2], v[3]),
+                new Point(v[4], v[5]),
+            )
+        } else if (values.length === 3) {
+            // Possibilities:
+            // - Three points (or part of points, only dict for example, or array (TODO: Add the array syntax for point)
+            // - Three lines
+            // - Three lines as text.
+            if(values.filter((x:any) => typeof x === 'string').length===3) {
+                return this.parse( ...values.map((x:string) => new Line(x)) )
+            }else if(values.filter((x:any) => x instanceof Line).length===3) {
+                // We have three lines
+                this._lines = {
+                    'AB': values[0],
+                    'BC': values[1],
+                    'AC': values[2]
+                };
+
+                // Get the intersection points -> build the triangle using these intersection points.
+                let intersect = values[0].intersection(values[1]);
+                if (intersect.hasIntersection) {
+                    this._B = intersect.point.clone();
+                } else {
+                    return this;
+                }
+                intersect = values[1].intersection(values[2]);
+                if (intersect.hasIntersection) {
+                    this._C = intersect.point.clone();
+                } else {
+                    return this;
+                }
+                intersect = values[2].intersection(values[0]);
+                if (intersect.hasIntersection) {
+                    this._A = intersect.point.clone();
+                } else {
+                    return this;
+                }
+            }else {
+                // At least, one of the value is not a point.
+                if (values.filter((x: any) => (x instanceof Point)).length < 3) {
+                    return this.parse(
+                        new Point(values[0]),
+                        new Point(values[1]),
+                        new Point(values[2])
+                    )
+                }
+
+                // 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 => {
+        this._A = this._A.clone();
+        this._B = this._B.clone();
+        this._C = this._C.clone();
+
+        this._lines = {
+            'AB': this._lines.AB.clone(),
+            'BC': this._lines.BC.clone(),
+            'AC': this._lines.AC.clone()
+        }
+
+        this._updateTriangle();
+        return this;
+    }
+
+
+    // ------------------------------------------
+    // Triangle operations and properties
+    // ------------------------------------------
+
+    /**
+     * Generate the Line object for the three segments of the triangle
+     */
+    private _updateTriangle = () => {
+        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 Point class for the given name
+     * @param ptName
+     */
+    private 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
+     */
+    private getSegment = (ptName1: string, ptName2: string): Vector => {
+        return new Vector(
+            this.getPointByName(ptName1),
+            this.getPointByName(ptName2)
+        );
+    }
+
+    private _calculateRemarquableLines = (): remarquableLines => {
+        const  bA= this._calculateBisectors('A'),
+            bB= this._calculateBisectors('B'),
+            bC= this._calculateBisectors('C')
+
+        let remarquables: remarquableLines = {
+            'medians': {
+                'A': new Line(this._A, this._middles.BC),
+                'B': new Line(this._B, this._middles.AC),
+                'C': new Line(this._C, this._middles.AB),
+                'intersection': null
+            },
+            'mediators': {
+                'AB': new Line(this._middles.AB, new Vector(this._A, this._B).normal()),
+                'AC': new Line(this._middles.AC, new Vector(this._A, this._C).normal()),
+                'BC': new Line(this._middles.BC, new Vector(this._B, this._C).normal()),
+                'intersection': null
+            },
+            'heights': {
+                'A': new Line(this._A, new Vector(this._B, this._C).normal()),
+                'B': new Line(this._B, new Vector(this._A, this._C).normal()),
+                'C': new Line(this._C, new Vector(this._A, this._B).normal()),
+                'intersection': null
+            },
+            'bisectors': {
+                'A': bA.internal,
+                'B': bB.internal,
+                'C': bB.internal,
+                'intersection': null
+            },
+            externalBisectors: {
+                'A': bA.external,
+                'B': bB.external,
+                'C': bC.external,
+                'intersection': null
+            }
+        }
+
+        // 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;
+    }
+
+    private _calculateBisectors = (pt: string): { internal: Line, external: Line } => {
+        let tlines = this.lines, 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;
+        }
+
+        let b1 = new Line(new Equation(d1.equation.left.clone().multiply(d2.n.simplify().norm), d2.equation.left.clone().multiply(d1.n.simplify().norm)).reorder(true).simplify()),
+            b2 = new Line(new Equation(d1.equation.left.clone().multiply(d2.n.simplify().norm), d2.equation.left.clone().multiply(d1.n.simplify().norm).opposed()).reorder(true).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}
+    }
+}