pimath 0.1.39 → 0.1.40

package/src/geometry/line3.ts

@@ -0,0 +1,206 @@
+/**
+ * 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 {Line3Propriety} from "../pimath.interface"
+
+
+export class Line3 {
+    // 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()
+
+    /**
+     * Value can be a mix of:
+     *
+     * @param values
+     */
+    constructor(A: Point, B: Point)
+    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()
+        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
+    }
+
+    set d(value: Vector) {
+        this.#d = value
+    }
+
+    get tex(): { parametric: string, system: string, cartesian: string } {
+        return {
+            parametric: `${Vector.asTex('x', 'y', 'z')} = ${Vector.asTex(this.#OA.x.tex, this.#OA.y.tex, this.#OA.z.tex)} + k\\cdot ${Vector.asTex(this.#d.x.tex, this.#d.y.tex, this.#d.z.tex)}`,
+            system: `\\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}\\\\
+    z &= ${(new Polynom(this.#OA.z)
+                    .add(new Monom(this.#d.z).multiply(new Monom('k'))))
+                    .reorder('k', true)
+                    .tex}
+\\end{aligned}\\right.`,
+            cartesian: `\\frac{ ${new Polynom('x', 1, this.#OA.x.clone().opposite()).tex} }{ ${this.direction.x.tex} } = \\frac{ ${new Polynom('y', 1, this.#OA.y.clone().opposite()).tex} }{ ${this.direction.y.tex} } = \\frac{ ${new Polynom('z', 1, this.#OA.z.clone().opposite()).tex} }{ ${this.direction.z.tex} }`
+        }
+    }
+
+    get display(): { parametric: string, system: string, cartesian: string } {
+        const OAx = this.#OA.x.display
+        const OAy = this.#OA.y.display
+        const OAz = this.#OA.z.display
+        const n = this.direction.simplify()
+        const nx = n.x.display
+        const ny = n.y.display
+        const nz = n.z.display
+
+        return {
+            parametric: `${Vector.asDisplay('x', 'y', 'z')} = ${Vector.asDisplay(this.#OA.x.display, this.#OA.y.display, this.#OA.z.display)} + k\\cdot ${Vector.asDisplay(this.#d.x.display, this.#d.y.display, this.#d.z.display)}`,
+            system: '',
+            cartesian: `(x-${OAx})/${nx} = (y-${OAy})/${ny} = (z-${OAz})/${nz}`
+        }
+    }
+
+    get direction(): Vector {
+        return this.#d.clone()
+    }
+
+    clone = (): this => {
+        this.#d = this.#d.clone()
+        this.#OA = this.#OA.clone()
+
+        return this
+    }
+    // ------------------------------------------
+    // Mathematical operations
+    // ------------------------------------------
+    isOnLine = (pt: Point): boolean => {
+        return false
+    }
+
+    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.')
+    }
+    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
+    }
+
+    intersection = (line: Line3): { point: Vector, hasIntersection: boolean, isParallel: boolean, isSame: boolean } => {
+
+        throw new Error('Method not implemented.')
+    }
+
+    distanceTo(pt: Point): { value: number, fraction: Fraction, tex: string } {
+        // Distance is:
+        // |(x - x0) x d| / |d|
+        const AP = new Vector(this.#OA, pt),
+            d = this.direction,
+            d2 = this.direction.normSquare,
+            num2 = AP.cross(d).normSquare,
+            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}}`
+        }
+    }
+
+    hitSegment(A: Point, B: Point): boolean {
+        const iPt = this.intersection(
+            new Line3(A, B)
+        )
+
+        // There is an intersection point
+        if (iPt.hasIntersection) {
+            return iPt.point.x.value >= Math.min(A.x.value, B.x.value)
+                && iPt.point.x.value <= Math.max(A.x.value, B.x.value)
+                && iPt.point.y.value >= Math.min(A.y.value, B.y.value)
+                && iPt.point.y.value <= Math.max(A.y.value, B.y.value)
+                && iPt.point.z.value >= Math.min(A.z.value, B.z.value)
+                && iPt.point.z.value <= Math.max(A.z.value, B.z.value)
+        }
+        return false
+    }
+
+    // getValueAtX = (value: Fraction | number): Fraction => {
+    //     const equ = this.equation.clone().isolate('y'),
+    //         F = new Fraction(value)
+
+    //     if (equ instanceof Equation) {
+    //         return equ.right.evaluate({ x: F }) as Fraction
+    //     }
+    //     return new Fraction().invalid()
+    // }
+
+    // getValueAtY = (value: Fraction | number): Fraction => {
+    //     const equ = this.equation.clone().isolate('x'),
+    //         F = new Fraction(value)
+
+    //     if (equ instanceof Equation) {
+    //         return equ.right.evaluate({ y: F }) as Fraction
+    //     }
+
+    //     return new Fraction().invalid()
+    // }
+
+    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))
+        )
+    }
+}

package/src/geometry/plane3.ts

@@ -0,0 +1,170 @@
+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)
+
+    constructor(config?: Plane3Config) {
+        if (config) {
+            this.parse(config)
+        }
+
+        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
+            this.normal = config.normal
+            return
+        }
+
+        if (config.point && config.directions?.length === 2) {
+            this.point = config.point
+            const [v1, v2] = config.directions
+            this.normal = v1.cross(v2)
+            return
+        }
+
+        if (config.equation) {
+            const cartesian = config.equation.moveLeft().reduce().left
+
+            const a = cartesian.monomByLetter('x').coefficient
+            const b = cartesian.monomByLetter('y').coefficient
+            const c = cartesian.monomByLetter('z').coefficient
+            const d = cartesian.monomByDegree(0).coefficient
+
+            // Get the normal vector
+            this.normal = new Vector(a, b, c)
+
+            // Get a point on the plane
+            if (a.isNotZero()) {
+                this.point = new Point(d.clone().divide(a).opposite(), 0, 0)
+            } else if (b.isNotZero()) {
+                this.point = new Point(0, d.clone().divide(b).opposite(), 0)
+            } else {
+                this.point = new Point(0, 0, d.clone().divide(c).opposite())
+            }
+            // Make sure it's considered as point
+            return
+        }
+
+        if (config.points?.length === 3 && config.points.every(p => p instanceof Vector)) {
+            const A = config.points[0]
+            const B = config.points[1]
+            const C = config.points[2]
+
+            const AB = new Vector(A, B)
+            const AC = new Vector(A, C)
+            this.normal = AB.cross(AC)
+            this.point = A
+            return
+        }
+
+        if (config.coefficients?.length === 4) {
+            const [a, b, c, d] = config.coefficients
+            this.normal = new Vector(a, b, c)
+            this.point = new Point(0, 0, -d)
+            return
+        }
+    }
+
+    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)
+        }
+
+        let direction: Vector
+        if (value instanceof Vector) {
+            if (value.dimension !== 3) {
+                throw new Error('Vector is not 3D')
+            }
+
+            direction = value
+        } else {
+            direction = value.direction
+        }
+
+        const a90 = radian ? Math.PI / 2 : 90
+        return a90 - this.normal.angle(direction, true, radian)
+    }
+
+    distanceTo(point: Vector): number {
+        return this.normal.dot(point).add(this.d).abs().value / this.normal.norm
+    }
+
+    intersectWithLine(line: Line3): Point {
+        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))
+    }
+
+    intersectWithPlane(plane: Plane3): Line3 {
+        const direction = this.normal.cross(plane.normal)
+
+        // Solve the system:
+        // p1 // p2 // z=0
+        const pt = new Point(0, 0, 0)
+        throw new Error('Intersection with plane  not yet implemented !')
+        return new Line3(pt, direction)
+    }
+
+    isPointOnPlane(pt: Point): boolean {
+        return this.normal.dot(pt).add(this.d).isZero()
+    }
+}

package/src/geometry/point.ts

@@ -0,0 +1,66 @@
+/**
+ * Vector2D module contains everything necessary to handle 2d vectors.
+ * @module Point
+ */
+
+import {Fraction} from "../coefficients"
+import type {InputValue} from "../pimath.interface"
+import {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>[]) {
+        super()
+
+        this.asPoint = true
+
+        // Initialize the vector
+        if (values.length > 0) {
+            this.parse(...values)
+        }
+    };
+
+    public override parse(...values: Vector[] | InputValue<Fraction>[]): this {
+        if (values.length === 1) {
+            if (values[0] instanceof Vector) {
+                this.array = values[0].copy()
+                return this
+            }
+
+            if (typeof values[0] === 'string') {
+                this.fromString(values[0])
+                return this
+            }
+        }
+
+
+        if (values.length > 1) {
+            if (values.some(x => x instanceof Vector)) {
+                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(','))
+            }
+
+            this.array = nbs
+        }
+
+        return this
+    }
+
+
+    public override clone(): Point {
+        const V = new Point()
+        V.array = this.copy()
+        V.asPoint = true
+        return V
+    }
+
+}

package/src/geometry/sphere3.ts

@@ -0,0 +1,214 @@
+import {Point} from "./point"
+import {Fraction} from "../coefficients"
+import {Equation, Polynom} from "../algebra"
+import type {InputValue} from "../pimath.interface"
+
+enum SPHERE3_FORMAT {
+    DEVELOPPED,
+    CENTER_RADIUS
+}
+
+export enum SPHERE3_RELATIVE_POSITION {
+    INTERIOR,
+    EXTERIOR,
+    SECANT,
+    TANGENT_INSIDE,
+    TANGENT_OUTSIDE,
+    SUPERPOSED,
+    CONCENTRIC
+}
+
+export class Sphere3 {
+    #center: Point | undefined = undefined
+    #squareRadius: Fraction | undefined = undefined
+    #equation: Equation | undefined = undefined
+    #format: SPHERE3_FORMAT = SPHERE3_FORMAT.CENTER_RADIUS
+
+    constructor(center?: Point, radius?: InputValue<Fraction>) {
+        if (center && radius) {
+            this.#center = center
+            this.#squareRadius = new Fraction(radius).clone().pow(2)
+            this.#computeEquation()
+        }
+        return this
+    }
+
+    fromEquation(equation: Equation | string): this {
+        const equ = new Equation(equation).moveLeft().reduce()
+
+        // Check that x, y, z has the same power and same coefficient.
+        const letters = ['x', 'y', 'z']
+
+        if (letters.some((letter) => equ.degree(letter).value !== 2)){
+            return this.makeUndefined()
+        }
+
+        const coefficient = equ.left.monomByDegree(2, 'x').coefficient
+        if (letters.some((letter) => equ.left.monomByDegree(2, letter).coefficient.isNotEqual(coefficient))) {
+            return this.makeUndefined()
+        }
+
+        this.#center = new Point(
+            equ.left.monomByDegree(1, 'x').coefficient.clone().opposite().divide(2),
+            equ.left.monomByDegree(1, 'y').coefficient.clone().opposite().divide(2),
+            equ.left.monomByDegree(1, 'z').coefficient.clone().opposite().divide(2)
+        )
+
+        this.#squareRadius = equ.left.monomByDegree(0)
+            .coefficient.clone().opposite()
+            .add(this.#center.x.clone().pow(2))
+            .add(this.#center.y.clone().pow(2))
+            .add(this.#center.z.clone().pow(2))
+
+        this.#computeEquation()
+        return this
+    }
+
+    get center(): Point {
+        if (this.#center === undefined) {
+            throw new Error('Sphere3 is undefined')
+        }
+        return this.#center
+    }
+
+    get squareRadius(): Fraction {
+        if (this.#squareRadius === undefined) {
+            throw new Error('Sphere3 is undefined')
+        }
+        return this.#squareRadius
+    }
+
+    get radius(): { tex: string, display: string, value: number } {
+        if (this.#squareRadius === undefined) {
+            throw new Error('Sphere3 is undefined')
+        }
+
+        if (this.#squareRadius.isSquare()) {
+            return {
+                tex: this.#squareRadius.clone().sqrt().tex,
+                display: this.#squareRadius.clone().sqrt().display,
+                value: this.#squareRadius.clone().sqrt().value
+            }
+        } else {
+            return {
+                tex: `\\sqrt{${this.#squareRadius.tex}}`,
+                display: `sqrt(${this.#squareRadius.display})`,
+                value: this.#squareRadius.clone().sqrt().value
+            }
+        }
+    }
+
+    get equation(): Equation {
+        if (this.#equation === undefined) {
+            throw new Error('Sphere3 is undefined')
+        }
+        return this.#equation
+    }
+
+    makeUndefined(): this {
+        this.#center = undefined
+        this.#squareRadius = undefined
+        this.#equation = undefined
+        return this
+    }
+
+    get centerRadius(): this {
+        this.#format = SPHERE3_FORMAT.CENTER_RADIUS
+        return this
+    }
+
+    get developped(): this {
+        this.#format = SPHERE3_FORMAT.DEVELOPPED
+        return this
+    }
+
+
+    get tex(): string {
+        return this.#output(true)
+    }
+
+    get display(): string {
+        return this.#output(false)
+    }
+
+    #output = (asTex: boolean): string => {
+        if (this.#equation === undefined) {
+            throw new Error('Sphere3 is undefined')
+        }
+
+        if (this.#format === SPHERE3_FORMAT.DEVELOPPED) {
+            return asTex ? this.#equation.tex : this.#equation.display
+        }
+
+        const output: string[] = []
+        const letters: ('x' | 'y' | 'z')[] = ['x', 'y', 'z']
+
+        letters.forEach((letter: 'x' | 'y' | 'z') => {
+            if (this.center[letter].isZero()) {
+                output.push(`${letter}^2`)
+            } else {
+                const P = new Polynom(letter).subtract(this.center[letter])
+                output.push(
+                    asTex ?
+                        `\\(${P.tex}\\)^2` :
+                        `(${P.display})^2`
+                )
+            }
+        })
+
+        return output.join('+') + '=' + (asTex ? this.squareRadius.tex : this.squareRadius.display)
+
+    }
+
+    #computeEquation(): void {
+        this.#equation = new Equation(
+            new Polynom('x').subtract(this.center.x).pow(2)
+                .add(
+                    new Polynom('y').subtract(this.center.y).pow(2)
+                )
+                .add(
+                    new Polynom('z').subtract(this.center.z).pow(2)
+                ),
+            new Polynom(this.squareRadius)
+        ).reduce()
+    }
+
+    static RELATIVE_POSITION = SPHERE3_RELATIVE_POSITION
+    relativePosition = (S: Sphere3): SPHERE3_RELATIVE_POSITION => {
+        const distance = this.center.distanceTo(S.center).value
+        const r1 = this.radius.value
+        const r2 = S.radius.value
+
+        if (distance > r1 + r2) {
+            return SPHERE3_RELATIVE_POSITION.EXTERIOR
+        }
+
+        if (distance === r1 + r2) {
+            return SPHERE3_RELATIVE_POSITION.TANGENT_OUTSIDE
+        }
+
+        if(distance===0) {
+            return r1===r2 ? SPHERE3_RELATIVE_POSITION.SUPERPOSED : SPHERE3_RELATIVE_POSITION.CONCENTRIC
+        }
+
+        if (distance === Math.abs(r1 - r2)) {
+            return SPHERE3_RELATIVE_POSITION.TANGENT_INSIDE
+        }
+
+
+        if (distance < Math.abs(r1 - r2)) {
+            return SPHERE3_RELATIVE_POSITION.INTERIOR
+        }
+
+        return SPHERE3_RELATIVE_POSITION.SECANT
+
+    }
+
+    isPointOnSphere = (P: Point): boolean => {
+        return this.#equation?.test({
+            x: P.x,
+            y: P.y,
+            z: P.z
+        }) ?? false
+    }
+}