pimath 0.1.40 → 0.2.1

package/src/geometry/line.ts

@@ -3,35 +3,40 @@
  */
 
 import {Numeric} from "../numeric"
-import {Fraction} from "../coefficients/fraction"
-import {Equation} from "../algebra/equation"
-import {Polynom} from "../algebra/polynom"
-import {Monom} from "../algebra/monom"
+import {Fraction} from "../coefficients"
+import {Equation, Monom, Polynom} from "../algebra"
 import {Vector} from "./vector"
 import {type InputValue, type IPiMathObject, LinePropriety} from "../pimath.interface"
 import {randomIntSym} from "../randomization/rndHelpers"
 import {Point} from "./point"
+import {Root} from "../coefficients/root"
+
+enum LINE_DISPLAY {
+    CARTESIAN,
+    CANONICAL,
+    MXH,
+    PARAMETRIC,
+    SYSTEM
+}
 
-export interface LineConfig {
-    direction?: Vector,
-    normal?: Vector
-    point?: Point,
-    points?: Point[],
+enum LINE_DIRECTION {
+    LEFT_TO_RIGHT = 'lr',
+    RIGHT_TO_LEFT = 'rl'
 }
 
 export class Line implements IPiMathObject<Line> {
     static PARALLEL = LinePropriety.Parallel
-    // A line is defined as the canonical form
     static PERPENDICULAR = LinePropriety.Perpendicular
     #OA: Vector
     // ax + by + c = 0
     #a: Fraction
+
+    // A line is defined as the canonical form
     #b: Fraction
     #c: Fraction
-    #d: Vector
-    #n: Vector
-    #outputMode: 'canonical' | 'equation' | 'mxh' | 'parametric' | 'system' = "canonical"
-    #reduceBeforeDisplay: boolean
+    #orientation: LINE_DIRECTION
+    // output mode.
+    #outputMode: LINE_DISPLAY = LINE_DISPLAY.CANONICAL
 
     /**
      * Value can be a mix of:
@@ -43,10 +48,7 @@ export class Line implements IPiMathObject<Line> {
         this.#b = new Fraction().zero()
         this.#c = new Fraction().zero()
         this.#OA = new Vector()
-        this.#d = new Vector()
-        this.#n = new Vector()
-
-        this.#reduceBeforeDisplay = true
+        this.#orientation = LINE_DIRECTION.LEFT_TO_RIGHT
 
         if (values.length > 0) {
             this.parse(...values)
@@ -72,53 +74,36 @@ export class Line implements IPiMathObject<Line> {
             if (values[0] instanceof Line) {
                 // Already a Line
                 return this.fromCoefficient(values[0].a, values[0].b, values[0].c)
-            } else if (values[0] instanceof Equation) {
+            }
+
+            if (values[0] instanceof Equation) {
                 // It's an Equation
                 return this.fromEquation(values[0])
-            } else if (typeof values[0] === "string") {
+            }
+
+            if (typeof values[0] === "string") {
                 // It's a string - create an Equation from it.
                 try {
                     const E = new Equation(values[0])
                     return this.parse(E)
                 } catch (e) {
+                    console.warn(e)
                     return this
                 }
             }
         }
 
-        // Two values are given: two vectors
-        if (values.length === 2 && values.every(x=>x instanceof Vector)) {
-            const formattedValues: Vector[] = values
-
-            if (formattedValues[0].asPoint && formattedValues[1].asPoint) {
-                // Two points
-                return this.fromPointAndDirection(formattedValues[0], new Vector(formattedValues[0], formattedValues[1]))
+        if (values.length === 2) {
+            if (values[0] instanceof Point && values[1] instanceof Point) {
+                return this.fromPoints(values[0], values[1])
             }
 
-            if (formattedValues[0].asPoint && !formattedValues[1].asPoint) {
-                // One point and one vector director
-                return this.fromPointAndDirection(formattedValues[0], formattedValues[1])
+            if (values[0] instanceof Point && values[1] instanceof Vector) {
+                return this.fromPointAndDirection(values[0], values[1])
             }
-
         }
 
-        if (values.length === 3) {
-            if (values[0] instanceof Vector && values[1] instanceof Vector) {
-                if (values[2] === LinePropriety.Perpendicular) {
-                    return this.fromPointAndNormal(values[0], values[1])
-                } else if (values[2] === LinePropriety.Parallel) {
-                    return this.fromPointAndDirection(values[0], values[1])
-                }
-            }
-
-            if (values[0] instanceof Vector && values[1] instanceof Line) {
-                if (values[2] === LinePropriety.Parallel || values[2] === null) {
-                    return this.fromPointAndLine(values[0], values[1], LinePropriety.Parallel)
-                } else {
-                    return this.fromPointAndLine(values[0], values[1], LinePropriety.Perpendicular)
-                }
-            }
-
+        if (values.length === 3 && values.every(x => Fraction.isFraction(x as InputValue<Fraction>))) {
             return this.fromCoefficient(
                 values[0] as InputValue<Fraction>,
                 values[1] as InputValue<Fraction>,
@@ -126,24 +111,16 @@ export class Line implements IPiMathObject<Line> {
             )
         }
 
-        console.log('Something wrong happened while creating the line')
-        console.log(values)
+        console.warn('Something wrong happened while creating the line')
+        console.warn(values)
         return this
     }
 
     // ------------------------------------------
     // Getter and setter
 
-    clone = (): this => {
-        this.#a = this.#a.clone()
-        this.#b = this.#b.clone()
-        this.#c = this.#c.clone()
-
-        this.#d = this.#d.clone()
-        this.#OA = this.#OA.clone()
-        this.#n = this.#n.clone()
-
-        return this
+    clone = (): Line => {
+        return new Line().fromCoefficient(this.#a, this.#b, this.#c)
     }
 
     get tex(): string {
@@ -151,45 +128,41 @@ export class Line implements IPiMathObject<Line> {
         // mxh          =>  y = -a/b x - c/b
         // parametric   =>  (xy) = OA + k*d
         // equation     => ax + by = -c
+        // system       => \begin{}...
+
         const output = this.#outputMode
-        this.#outputMode = 'canonical'
+        this.#outputMode = LINE_DISPLAY.CANONICAL
+
         switch (output) {
-            case 'equation':
+            case LINE_DISPLAY.CARTESIAN:
                 return this.getEquation().reorder().tex
-            case 'mxh':
+            case LINE_DISPLAY.MXH:
                 return this.slope.isInfinity() ?
                     'x=' + this.OA.x.tex :
                     'y=' + new Polynom().parse('x', this.slope, this.height).tex
-            case 'parametric':
-            case 'system': {
-                const d = this.#d.clone()
-                if (this.#reduceBeforeDisplay) {
-                    d.simplify()
-                }
+            case LINE_DISPLAY.PARAMETRIC:
+            case LINE_DISPLAY.SYSTEM: {
+                const d = this.d.clone().simplify()
 
-                if (output === 'parametric') {
+                if (output === LINE_DISPLAY.PARAMETRIC) {
                     return `${Vector.asTex('x', 'y')} = ${Vector.asTex(this.#OA.x.tex, this.#OA.y.tex)} + k\\cdot ${Vector.asTex(d.x.tex, d.y.tex)}`
                 } else {
-                    return `\\left\\{\\begin{aligned}
-            x &= ${(new Polynom(this.#OA.x)
-                            .add(new Monom(this.#d.x).multiply(new Monom('k'))))
-                            .reorder('k', true)
-                            .tex}\\\\ 
-            y &= ${(new Polynom(this.#OA.y)
-                            .add(new Monom(this.#d.y).multiply(new Monom('k'))))
-                            .reorder('k', true)
-                            .tex}
-            \\end{aligned}\\right.`
+                    return `\\left\\{\\begin{aligned}\n\tx &= ${(new Polynom(this.#OA.x)
+                        .add(new Monom(d.x).multiply(new Monom('k'))))
+                        .reorder('k', true)
+                        .tex}\\\\\n\ty &= ${(new Polynom(this.#OA.y)
+                        .add(new Monom(d.y).multiply(new Monom('k'))))
+                        .reorder('k', true)
+                        .tex}\n\\end{aligned}\\right.`
                 }
             }
-            default:
-                {
-                    const canonical = this.getEquation()
-                    if (this.#a.isNegative()) {
-                        canonical.multiply(-1)
-                    }
-                    return canonical.tex
+            default: {
+                const canonical = this.getEquation()
+                if (canonical.left.monoms[0].coefficient.isNegative()) {
+                    canonical.multiply(-1)
                 }
+                return canonical.tex
+            }
         }
 
     }
@@ -199,27 +172,33 @@ export class Line implements IPiMathObject<Line> {
         // mxh          =>  y = -a/b x - c/b
         // parametric   =>  (xy) = OA + k*d // not relevant in display mode.
         const output = this.#outputMode
-        this.#outputMode = 'canonical'
+        this.#outputMode = LINE_DISPLAY.CANONICAL
 
         switch (output) {
-            case 'equation':
+            case LINE_DISPLAY.CARTESIAN:
                 return this.getEquation().reorder().display
-            case 'mxh':
+            case LINE_DISPLAY.MXH:
                 return this.slope.isInfinity() ?
                     'x=' + this.OA.x.display :
                     'y=' + new Polynom().parse('x', this.slope, this.height).display
-            case 'parametric': {
-                const d = this.#d.clone()
-                if (this.#reduceBeforeDisplay) {
-                    d.simplify()
-                }
-
+            case LINE_DISPLAY.PARAMETRIC: {
+                const d = this.d.clone().simplify()
                 return `((x,y))=((${this.#OA.x.display},${this.#OA.y.display}))+k((${d.x.display},${d.y.display}))`
             }
+            case LINE_DISPLAY.SYSTEM: {
+                const d = this.d.clone().simplify()
+                // {(2x,+,17y,=,23),(x,-,y,=,5):}
+                const px = (new Polynom(this.#OA.x).add(new Monom(d.x).multiply(new Monom('k'))))
+                    .reorder('k', true)
+                const py = (new Polynom(this.#OA.y).add(new Monom(d.y).multiply(new Monom('k'))))
+                    .reorder('k', true)
+
+                return `{(x,=,${px.display}),(y,=,${py.display}):}`
+            }
             default: {
                 const canonical = this.getEquation()
                 // Make sur the first item is positive.
-                if (this.#a.isNegative()) {
+                if (canonical.left.monoms[0].coefficient.isNegative()) {
                     canonical.multiply(-1)
                 }
                 return canonical.display
@@ -232,8 +211,8 @@ export class Line implements IPiMathObject<Line> {
         return this.#OA
     }
 
-    set OA(value: Vector) {
-        this.#OA = value
+    set OA(value: Vector | Point) {
+        this.fromPointAndNormal(value, this.n)
     }
 
     get a(): Fraction {
@@ -244,6 +223,31 @@ export class Line implements IPiMathObject<Line> {
         this.#a = value
     }
 
+    get asCanonical(): this {
+        this.#outputMode = LINE_DISPLAY.CANONICAL
+        return this
+    }
+
+    get asCartesian(): this {
+        this.#outputMode = LINE_DISPLAY.CARTESIAN
+        return this
+    }
+
+    get asMxh(): this {
+        this.#outputMode = LINE_DISPLAY.MXH
+        return this
+    }
+
+    get asParametric(): this {
+        this.#outputMode = LINE_DISPLAY.PARAMETRIC
+        return this
+    }
+
+    get asSystem(): this {
+        this.#outputMode = LINE_DISPLAY.SYSTEM
+        return this
+    }
+
     get b(): Fraction {
         return this.#b
     }
@@ -260,32 +264,8 @@ export class Line implements IPiMathObject<Line> {
         this.#c = value
     }
 
-    // get system(): { x: Equation, y: Equation } {
-    //     const e1 = new Equation(
-    //         new Polynom('x'),
-    //         new Polynom(this.#OA.x)
-    //             .add(new Monom('k').multiply(this.#d.x))
-    //     ),
-    //         e2 = new Equation(
-    //             new Polynom('y'),
-    //             new Polynom(this.#OA.y)
-    //                 .add(new Monom('k').multiply(this.#d.y))
-    //         )
-
-    //     return { x: e1, y: e2 }
-    // }
-
-    get canonical(): this {
-        this.#outputMode = 'canonical'
-        return this
-    }
-
     // ------------------------------------------
-    canonicalAsFloatCoefficient(decimals?: number): string {
-        if (decimals === undefined) {
-            decimals = 2
-        }
-
+    canonicalAsFloatCoefficient(decimals = 2): string {
         let canonical = ''
 
         if (!this.#a.isZero()) {
@@ -317,69 +297,104 @@ export class Line implements IPiMathObject<Line> {
     }
 
     get d(): Vector {
-        return this.#d
+        const director = new Vector(this.#b.clone(), this.#a.clone().opposite())
+
+        if (
+            this.#orientation === LINE_DIRECTION.LEFT_TO_RIGHT && director.x.isNegative() ||
+            this.#orientation === LINE_DIRECTION.RIGHT_TO_LEFT && director.x.isPositive()
+        ) {
+            director.opposite()
+        }
+
+        return director
     }
 
     set d(value: Vector) {
-        this.#d = value
+        this.fromPointAndDirection(this.OA, value)
     }
 
     get director(): Vector {
-        return this.#d.clone()
+        return this.d
     }
 
-    distanceTo(pt: Point): { value: number, fraction: Fraction, tex: string } {
+    distanceTo(pt: Point): Root {
         const numerator = pt.x.clone().multiply(this.#a)
             .add(pt.y.clone().multiply(this.#b))
-            .add(this.#c).abs(),
-            d2 = this.normal.normSquare
+            .add(this.#c).abs()
+        const d2 = this.normal.normSquare
 
         // The denominator is null - shouldn't be possible
         if (d2.isZero()) {
-            return {
-                value: NaN,
-                tex: 'Not a line',
-                fraction: new Fraction().infinite()
-            }
-        }
-        // The denominator is a perfect square - simplify the tex result
-        const value = numerator.value / Math.sqrt(d2.value),
-            F = numerator.clone().divide(d2.clone().sqrt())
-
-        // The denominator is a perfect square.
-        if (d2.isSquare()) {
-            return {
-                value,
-                tex: F.tex,
-                fraction: F
-            }
+            return new Root(0)
         }
-        // Complete answer...
-        return {
-            value,
-            tex: `\\frac{${numerator.tex}}{\\sqrt{${d2.tex}}}`,
-            fraction: F
-        }
-    }
 
-    get equation(): this {
-        this.#outputMode = 'equation'
-        return this
-    }
+        return new Root().from(2, d2.inverse(), numerator)
+
+        // The denominator is a perfect square - simplify the tex result
+        // const value = numerator.value / Math.sqrt(d2.value)
+        // const F = numerator.clone().divide(d2.clone().sqrt())
 
-    fromCoefficient = (a: InputValue<Fraction>, b: InputValue<Fraction>, c: InputValue<Fraction>): this => {
+        //
+        // if (d2.isSquare()) {
+        //
+        //     return {
+        //         value,
+        //         tex: F.tex,
+        //         fraction: F
+        //     }
+        // }
+        // // Complete answer...
+        // return {
+        //     value,
+        //     tex: `\\frac{${numerator.tex}}{\\sqrt{${d2.tex}}}`,
+        //     fraction: F
+        // }
+    }
+
+    fromCoefficient(a: InputValue<Fraction>, b: InputValue<Fraction>, c: InputValue<Fraction>): this {
         this.#a = new Fraction(a)
         this.#b = new Fraction(b)
         this.#c = new Fraction(c)
 
-        this.#d = new Vector(this.#b.clone(), this.#a.clone().opposite())
-        this.#OA = new Vector(new Fraction().zero(), this.#c.clone())
-        this.#n = this.#d.clone().normal()
+        // make sure the coefficients are relative...
+        const lcm = [this.#a, this.#b, this.#c].every(k => k.exact)
+            ? Numeric.lcm(this.#a.denominator, this.#b.denominator, this.#c.denominator)
+            : 1
+
+        if (lcm > 1) {
+            this.#a.multiply(lcm).reduce()
+            this.#b.multiply(lcm).reduce()
+            this.#c.multiply(lcm).reduce()
+        }
+
+        if (this.#b.isZero()) {
+            // ax+c=0 => x = -c/a
+            this.#OA = new Vector(this.#c.clone().divide(this.#a).opposite(), 0)
+            return this
+        }
+
+        // ax+by+c=0 => x=0 => y = a/b x - c/b = (ax-c)/b
+        for (let x = 0; x < this.#b.value; x++) {
+            const y = this.#a.clone().divide(this.#b)
+                .multiply(x)
+                .subtract(this.#c.clone().divide(this.#b))
+                .reduce()
+
+            this.#OA = new Vector(x, y)
+
+            if (y.isRelative()) {
+                return this
+            }
+        }
+
+        // no "nice" point... do it with 'x=0'
+        const y = this.#c.clone().divide(this.#b).opposite().reduce()
+        this.#OA = new Vector(0, y)
 
         return this
     }
 
-    fromEquation = (equ: Equation): this => {
+    fromEquation(equ: Equation): this {
         // Reorder the equation
         equ.reorder(true)
 
@@ -410,66 +425,60 @@ export class Line implements IPiMathObject<Line> {
         )
     }
 
-    fromPointAndDirection = (P: Point, d: Vector): this => {
-        // OX = OP + k*d
-        // x = px + kdx     * dy
-        // y = py + kdy     * dx
-        // ------------------
-        // dy * x = px * dy + kdxdy
-        // dx * y = py * dx + kdxdy
-        // ------------------
-        // dy * x - dx * y = px * dy - py * dx
-        // dy * x - dx * y - (px * dy - py * dx) = 0
-        this.fromCoefficient(
-            d.y,
-            d.x.clone().opposite(),
-            P.x.clone().multiply(d.y).subtract(P.y.clone().multiply(d.x)).opposite()
-        )
-
-        // Choose the current values as point and direction vector instead of the automatic version.
-        this.#OA = P.clone()
-        this.#d = d.clone()
-        this.#n = this.#d.clone().normal()
+    fromParallel(parallel: Line, point: Point): this {
+        return this.fromPointAndNormal(point, parallel.n)
+    }
 
-        return this
+    fromPerpendicular(perpendicular: Line, point: Point): this {
+        return this.fromPointAndNormal(point, perpendicular.d)
     }
 
-    fromPointAndLine = (P: Vector, L: Line, orientation?: LinePropriety): this => {
+    fromPointAndDirection(P: Point | Vector, d: Vector): this {
+        this.#orientation = d.x.isPositive()
+            ? LINE_DIRECTION.LEFT_TO_RIGHT
+            : LINE_DIRECTION.RIGHT_TO_LEFT
 
-        if (orientation === undefined) {
-            orientation = LinePropriety.Parallel
-        }
+        return this.fromPointAndNormal(P, d.clone().normal())
+    }
+
+    fromPointAndLine(P: Vector, L: Line, orientation: LinePropriety = LinePropriety.Parallel): this {
 
-        if (orientation === LinePropriety.Parallel) {
-            return this.fromPointAndNormal(P, L.normal)
-        } else if (orientation === LinePropriety.Perpendicular) {
+        if (orientation === LinePropriety.Perpendicular) {
             return this.fromPointAndNormal(P, L.director)
         }
 
-        return this
+        return this.fromPointAndNormal(P, L.normal)
     }
 
-    fromPointAndNormal = (P: Point, n: Vector): this => {
-        return this.fromCoefficient(
+    fromPointAndNormal = (P: Point | Vector, n: Vector): this => {
+        if (n.isZero()) {
+            console.warn('Normal vector is null.')
+            return this
+        }
+
+        this.fromCoefficient(
             n.x,
             n.y,
             P.x.clone().multiply(n.x)
                 .add(P.y.clone().multiply(n.y)).opposite()
         )
+
+        this.#OA = new Vector(P.clone())
+
+        return this
     }
 
-    fromPoints(pt1: Point, pt2: Point){
-        return this.fromPointAndDirection(pt1, new Vector(pt1, pt2))
+    // ------------------------------------------
+    // Creation / parsing functions
+
+    fromPoints(A: Point, B: Point) {
+        return this.fromPointAndNormal(A, new Vector(A, B).normal())
     }
 
     // ------------------------------------------
     getEquation(): Equation {
         const equ = new Equation(new Polynom().parse('xy', this.#a, this.#b, this.#c), new Polynom('0'))
-        if (this.#reduceBeforeDisplay) {
-            return equ.simplify()
-        } else {
-            return equ
-        }
+        return equ.simplify()
     }
 
     getValueAtX = (value: Fraction | number): Fraction => {
@@ -477,20 +486,17 @@ export class Line implements IPiMathObject<Line> {
             F = new Fraction(value)
 
         if (equ instanceof Equation) {
-            return equ.right.evaluate({ x: F }) as Fraction
+            return equ.right.evaluate({x: F}) as Fraction
         }
         return new Fraction().invalid()
     }
 
-    // ------------------------------------------
-    // Creation / parsing functions
-
     getValueAtY = (value: Fraction | number): Fraction => {
         const equ = this.getEquation().isolate('x'),
             F = new Fraction(value)
 
         if (equ instanceof Equation) {
-            return equ.right.evaluate({ y: F }) as Fraction
+            return equ.right.evaluate({y: F}) as Fraction
         }
 
         return new Fraction().invalid()
@@ -516,6 +522,7 @@ export class Line implements IPiMathObject<Line> {
     }
 
     intersection = (line: Line): { point: Point, hasIntersection: boolean, isParallel: boolean, isSame: boolean } => {
+        // TODO: rework Line.intersection
         const Pt = new Point()
         let isParallel = false, isSame = false
 
@@ -562,8 +569,12 @@ export class Line implements IPiMathObject<Line> {
         }
     }
 
+    isHorizontal(): boolean {
+        return this.slope.value === 0
+    }
+
     // ------------------------------------------
-    isOnLine = (pt: Vector): boolean => {
+    isOnLine(pt: Point): boolean {
         return this.#a.clone()
             .multiply(pt.x)
             .add(
@@ -586,31 +597,19 @@ export class Line implements IPiMathObject<Line> {
     isSameAs = (line: Line): boolean => {
         return this.slope.isEqual(line.slope) && this.height.isEqual(line.height)
     }
-    // ------------------------------------------
-    // Mathematical operations
 
     isVertical = (): boolean => {
         return this.slope.isInfinity()
     }
 
-    get mxh(): this {
-        this.#outputMode = 'mxh'
-        return this
-    }
-
     get n(): Vector {
-        return this.#n
+        return this.d.normal()
     }
 
     get normal(): Vector {
         return new Vector(this.#a, this.#b)
     }
 
-    get parametric(): this {
-        this.#outputMode = 'parametric'
-        return this
-    }
-
     randomNearPoint = (k?: number): Point => {
         const pt = this.randomPoint(k)
 
@@ -627,22 +626,12 @@ export class Line implements IPiMathObject<Line> {
 
     randomPoint = (k?: number): Point => {
         // Return a random point on the line.
-        const pt = this.#d
+        const pt = this.d
             .clone()
             .multiplyByScalar(randomIntSym((k === undefined || k <= 1) ? 3 : k, false))
             .add(this.#OA)
 
-        pt.asPoint = true
-
-        return pt
-    }
-
-    get reduceBeforeDisplay(): boolean {
-        return this.#reduceBeforeDisplay
-    }
-
-    set reduceBeforeDisplay(value: boolean) {
-        this.#reduceBeforeDisplay = value
+        return new Point(pt)
     }
 
     simplify = (): this => {
@@ -658,20 +647,7 @@ export class Line implements IPiMathObject<Line> {
         return this
     }
 
-    simplifyDirection = (): this => {
-        this.#d.simplify()
-        return this
-    }
-
     get slope(): Fraction {
         return this.#a.clone().opposite().divide(this.#b)
     }
-
-    // ------------------------------------------
-    // Special functions
-
-    get system(): this {
-        this.#outputMode = 'system'
-        return this
-    }
 }