pimath 0.1.40 → 0.2.1

package/src/geometry/line3.ts

@@ -2,19 +2,19 @@
  * This class works for 2d line in a plane.
  */
 
-import { Fraction } from "../coefficients/fraction"
-import { Polynom } from "../algebra/polynom"
-import { Monom } from "../algebra/monom"
-import { randomIntSym } from "../randomization/rndHelpers"
-import { Vector } from "./vector"
-import { Point } from "./point"
+import {Fraction} from "../coefficients/fraction"
+import {Polynom} from "../algebra/polynom"
+import {Monom} from "../algebra/monom"
+import {randomIntSym} from "../randomization/rndHelpers"
+import {Vector} from "./vector"
+import {Point} from "./point"
 import {Line3Propriety} from "../pimath.interface"
 
 
 export class Line3 {
+    static PARALLEL = Line3Propriety.Parallel
     // A line is defined as the canonical form
     static PERPENDICULAR = Line3Propriety.Perpendicular
-    static PARALLEL = Line3Propriety.Parallel
     // ax + by + c = 0
     #OA: Point = new Point()
     #d: Vector = new Vector()
@@ -28,27 +28,15 @@ export class Line3 {
     constructor(A: Point, d: Vector)
     constructor(A: Point, d: Vector | Point) {
         this.#OA = A.clone()
-        this.#d = d.asPoint ? new Vector(A, d) : d.clone()
+        this.#d = (d instanceof Point) ? new Vector(A, d) : d.clone()
         return this
     }
 
-    get OA(): Point {
-        return this.#OA
-    }
-
-    set OA(value: Point) {
-        this.#OA = value
-    }
-    get point(): Point {
-        return this.#OA.clone()
-    }
-
-    get d(): Vector {
-        return this.#d
-    }
+    clone = (): this => {
+        this.#d = this.#d.clone()
+        this.#OA = this.#OA.clone()
 
-    set d(value: Vector) {
-        this.#d = value
+        return this
     }
 
     get tex(): { parametric: string, system: string, cartesian: string } {
@@ -88,53 +76,24 @@ export class Line3 {
         }
     }
 
-    get direction(): Vector {
-        return this.#d.clone()
+    get OA(): Point {
+        return this.#OA
     }
 
-    clone = (): this => {
-        this.#d = this.#d.clone()
-        this.#OA = this.#OA.clone()
-
-        return this
-    }
-    // ------------------------------------------
-    // Mathematical operations
-    // ------------------------------------------
-    isOnLine = (pt: Point): boolean => {
-        return false
+    set OA(value: Point) {
+        this.#OA = value
     }
 
-    isParallelTo = (line: Line3): boolean => {
-        // Do they have the isSame direction ?
-        throw new Error('Method not implemented.')
-    }
-    isSameAs = (line: Line3): boolean => {
-        throw new Error('Method not implemented.')
-    }
-    isPerpendicularTo = (line: Line3): boolean => {
-        throw new Error('Method not implemented.')
-    }
-    isVertical = (): boolean => {
-        throw new Error('Method not implemented.')
+    get d(): Vector {
+        return this.#d
     }
-    simplify = (): this => {
-        throw new Error('Method not implemented.')
-        // const lcm = Numeric.lcm(this.#a.denominator, this.#b.denominator, this.#c.denominator),
-        //     gcd = Numeric.gcd(this.#a.numerator, this.#b.numerator, this.#c.numerator)
-
-        // this.fromCoefficient(
-        //     this.#a.clone().multiply(lcm).divide(gcd),
-        //     this.#b.clone().multiply(lcm).divide(gcd),
-        //     this.#c.clone().multiply(lcm).divide(gcd),
-        // )
 
-        // return this
+    set d(value: Vector) {
+        this.#d = value
     }
 
-    intersection = (line: Line3): { point: Vector, hasIntersection: boolean, isParallel: boolean, isSame: boolean } => {
-
-        throw new Error('Method not implemented.')
+    get direction(): Vector {
+        return this.#d.clone()
     }
 
     distanceTo(pt: Point): { value: number, fraction: Fraction, tex: string } {
@@ -147,13 +106,14 @@ export class Line3 {
             num2d2 = num2.clone().divide(d2),
             dnum = num2d2.clone().sqrt()
 
-        console.log('CROSS', AP.cross(d).display)
         return {
             value: Math.sqrt(num2d2.value),
             fraction: num2d2.clone().sqrt(),
-            tex: dnum.isExact() ? dnum.tex : `\\sqrt{${num2d2.tex}}`
+            tex: dnum.exact ? dnum.tex : `\\sqrt{${num2d2.tex}}`
         }
     }
+    // ------------------------------------------
+    // Mathematical operations
 
     hitSegment(A: Point, B: Point): boolean {
         const iPt = this.intersection(
@@ -172,6 +132,48 @@ export class Line3 {
         return false
     }
 
+    intersection = (line: Line3): { point: Vector, hasIntersection: boolean, isParallel: boolean, isSame: boolean } => {
+
+        throw new Error('Method not implemented.')
+    }
+
+    // ------------------------------------------
+    isOnLine = (pt: Point): boolean => {
+        return false
+    }
+
+    isParallelTo = (line: Line3): boolean => {
+        // Do they have the isSame direction ?
+        throw new Error('Method not implemented.')
+    }
+
+    isPerpendicularTo = (line: Line3): boolean => {
+        throw new Error('Method not implemented.')
+    }
+
+    isSameAs = (line: Line3): boolean => {
+        throw new Error('Method not implemented.')
+    }
+
+    isVertical = (): boolean => {
+        throw new Error('Method not implemented.')
+    }
+
+    get point(): Point {
+        return this.#OA.clone()
+    }
+
+    randomPoint = (max = 5): Point => {
+        const A = this.#OA.clone(),
+            k = new Fraction(randomIntSym(max, false))
+
+        return new Point(
+            A.x.clone().add(this.#d.x.clone().multiply(k)),
+            A.y.clone().add(this.#d.y.clone().multiply(k)),
+            A.z.clone().add(this.#d.z.clone().multiply(k))
+        )
+    }
+
     // getValueAtX = (value: Fraction | number): Fraction => {
     //     const equ = this.equation.clone().isolate('y'),
     //         F = new Fraction(value)
@@ -193,14 +195,17 @@ export class Line3 {
     //     return new Fraction().invalid()
     // }
 
-    randomPoint = (max = 5): Point => {
-        const A = this.#OA.clone(),
-            k = new Fraction(randomIntSym(max, false))
+    simplify = (): this => {
+        throw new Error('Method not implemented.')
+        // const lcm = Numeric.lcm(this.#a.denominator, this.#b.denominator, this.#c.denominator),
+        //     gcd = Numeric.gcd(this.#a.numerator, this.#b.numerator, this.#c.numerator)
 
-        return new Point(
-            A.x.clone().add(this.#d.x.clone().multiply(k)),
-            A.y.clone().add(this.#d.y.clone().multiply(k)),
-            A.z.clone().add(this.#d.z.clone().multiply(k))
-        )
+        // this.fromCoefficient(
+        //     this.#a.clone().multiply(lcm).divide(gcd),
+        //     this.#b.clone().multiply(lcm).divide(gcd),
+        //     this.#c.clone().multiply(lcm).divide(gcd),
+        // )
+
+        // return this
     }
 }

package/src/geometry/plane3.ts

@@ -1,13 +1,12 @@
-import { Equation } from "../algebra/equation"
-import { Polynom } from "../algebra/polynom"
-import { Fraction } from "../coefficients/fraction"
-import { Line3 } from "./line3"
-import { Point } from "./point"
-import { Vector } from "./vector"
+import {Equation} from "../algebra/equation"
+import {Polynom} from "../algebra/polynom"
+import {Fraction} from "../coefficients/fraction"
+import {Line3} from "./line3"
+import {Point} from "./point"
+import {Vector} from "./vector"
 import type {Plane3Config} from "../pimath.interface"
 
 
-
 export class Plane3 {
     #normal: Vector = new Vector(0, 0, 1)
     #point: Point = new Point(0, 0, 0)
@@ -20,50 +19,6 @@ export class Plane3 {
         return this
     }
 
-    get normal(): Vector {
-        return this.#normal
-    }
-    set normal(value: Vector) {
-        this.#normal = value
-        this.#normal.asPoint = false
-    }
-    get point(): Point {
-        return this.#point
-    }
-    set point(value: Point) {
-        this.#point = value
-        this.#point.asPoint = true
-    }
-
-    get a(): Fraction {
-        return this.#normal.x
-    }
-    get b(): Fraction {
-        return this.#normal.y
-    }
-    get c(): Fraction {
-        return this.#normal.z
-    }
-    get d(): Fraction {
-        return this.#normal.dot(this.#point).opposite()
-    }
-
-    get tex(): string {
-        // return the cartesian equation of the plane
-        return new Equation(
-            new Polynom('xyz', this.a, this.b, this.c, this.d),
-            new Polynom(0)
-        ).reduce().tex
-    }
-
-    get display(): string {
-        // return the cartesian equation of the plane
-        return new Equation(
-            new Polynom('xyz', this.a, this.b, this.c, this.d),
-            new Polynom(0)
-        ).reduce().display
-    }
-
     parse(config: Plane3Config) {
         if (config.point && config.normal) {
             this.point = config.point
@@ -121,9 +76,32 @@ export class Plane3 {
         }
     }
 
+    get tex(): string {
+        // return the cartesian equation of the plane
+        return new Equation(
+            new Polynom('xyz', this.a, this.b, this.c, this.d),
+            new Polynom(0)
+        ).reduce().tex
+    }
+
+    get display(): string {
+        // return the cartesian equation of the plane
+        return new Equation(
+            new Polynom('xyz', this.a, this.b, this.c, this.d),
+            new Polynom(0)
+        ).reduce().display
+    }
+
+    get a(): Fraction {
+        return this.#normal.x
+    }
+
     angle(vector: Vector, sharp?: boolean, radian?: boolean): number
+
     angle(line: Line3, sharp?: boolean, radian?: boolean): number
+
     angle(plane: Plane3, sharp?: boolean, radian?: boolean): number
+
     angle(value: Plane3 | Line3 | Vector, sharp?: boolean, radian?: boolean): number {
         if (value instanceof Plane3) {
             return this.normal.angle(value.normal, sharp, radian)
@@ -144,20 +122,35 @@ export class Plane3 {
         return a90 - this.normal.angle(direction, true, radian)
     }
 
-    distanceTo(point: Vector): number {
+    get b(): Fraction {
+        return this.#normal.y
+    }
+
+    get c(): Fraction {
+        return this.#normal.z
+    }
+
+    get d(): Fraction {
+        return this.#normal.dot(this.#point).opposite()
+    }
+
+    distanceTo(point: Point): number {
         return this.normal.dot(point).add(this.d).abs().value / this.normal.norm
     }
 
     intersectWithLine(line: Line3): Point {
-        const { point, direction } = line
+        const {point, direction} = line
         const t = this.normal.dot(point).add(this.d).divide(this.normal.dot(direction).opposite())
-        return point.clone().add(direction.clone().multiplyByScalar(t))
+        return new Point(
+            new Vector(point)
+                .add(direction.clone().multiplyByScalar(t))
+        )
     }
 
     intersectWithPlane(plane: Plane3): Line3 {
         const direction = this.normal.cross(plane.normal)
 
-        // Solve the system:
+        // Solve the asSystem:
         // p1 // p2 // z=0
         const pt = new Point(0, 0, 0)
         throw new Error('Intersection with plane  not yet implemented !')
@@ -167,4 +160,20 @@ export class Plane3 {
     isPointOnPlane(pt: Point): boolean {
         return this.normal.dot(pt).add(this.d).isZero()
     }
+
+    get normal(): Vector {
+        return this.#normal
+    }
+
+    set normal(value: Vector | Point) {
+        this.#normal = new Vector(value)
+    }
+
+    get point(): Point {
+        return this.#point
+    }
+
+    set point(value: Point | Vector) {
+        this.#point = new Point(value)
+    }
 }

package/src/geometry/point.ts

@@ -1,32 +1,29 @@
 /**
- * Vector2D module contains everything necessary to handle 2d vectors.
+ * POint module contains everything necessary to handle 2d Points
+ * It's a "wrapper" of the Vector class.
  * @module Point
  */
 
 import {Fraction} from "../coefficients"
 import type {InputValue} from "../pimath.interface"
-import {Vector} from "./vector"
+import {Root} from "../coefficients/root"
+import {TupleN} from "./TupleN"
+import type {Vector} from "./vector"
 
-export class Point extends Vector {
 
-    constructor()
-    constructor(value: Vector)
-    constructor(start: Vector, end: Vector)
-    constructor(...values: InputValue<Fraction>[])
-    constructor(...values: Vector[] | InputValue<Fraction>[]) {
+export class Point extends TupleN {
+    constructor(...values: (Point|Vector)[] | InputValue<Fraction>[]) {
         super()
 
-        this.asPoint = true
-
         // Initialize the vector
         if (values.length > 0) {
             this.parse(...values)
         }
     };
 
-    public override parse(...values: Vector[] | InputValue<Fraction>[]): this {
+    public parse(...values: (Point|Vector)[] | InputValue<Fraction>[]): this {
         if (values.length === 1) {
-            if (values[0] instanceof Vector) {
+            if (values[0] instanceof TupleN) {
                 this.array = values[0].copy()
                 return this
             }
@@ -39,14 +36,14 @@ export class Point extends Vector {
 
 
         if (values.length > 1) {
-            if (values.some(x => x instanceof Vector)) {
+            if (values.some(x => x instanceof Point)) {
                 throw new Error('Creating a point with  multiple argument requires an input fraction')
             }
 
             const nbs: Fraction[] = values.map(x => new Fraction(x as InputValue<Fraction>))
 
             if (nbs.some(x => x.isNaN())) {
-                throw new Error('The value is not a valid point sting (a,b): ' + values.join(','))
+                throw new Error('The given values are not a valid point string (a,b): ')
             }
 
             this.array = nbs
@@ -55,12 +52,53 @@ export class Point extends Vector {
         return this
     }
 
+    public clone(): Point {
+        return new Point(...this.copy())
+    }
+
+    get tex(): string {
+        return `\\left(${this.array.map(x => x.tex).join(';')}\\right)`
+    }
+
+    get display(): string {
+        return `(${this.array.map(x => x.display).join(';')})`
+    }
+
+    distanceTo(B: Point): Root {
+        if (this.dimension !== B.dimension) {
+            throw new Error('The two points must have the same dimensions.')
+        }
+
+        const AB = this.array
+            .map((x, index) => B.array[index].clone().subtract(x))
+
+        const distance2 = AB
+            .reduce(
+                (acc, x) =>
+                    acc.add(x.clone().pow(2)), new Fraction(0)
+            )
 
-    public override clone(): Point {
-        const V = new Point()
-        V.array = this.copy()
-        V.asPoint = true
-        return V
+        return new Root().from(2, distance2).reduce()
     }
 
+    public isEqual(pt: Point): boolean {
+        return this.x.value===pt.x.value && this.y.value===pt.y.value
+    }
+
+    public isEqualXY(x: InputValue<Fraction>, y: InputValue<Fraction>): boolean {
+        return this.isEqual(new Point(x, y))
+    }
+
+    middleOf(V1: Point, V2: Point): 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
+    }
 }