fluidcad 0.0.2

package/lib/dist/math/quaternion.test.js

@@ -0,0 +1,278 @@
+import { describe, it, expect } from "vitest";
+import { Quaternion } from "./quaternion.js";
+import { Vector3d } from "./vector3d.js";
+describe("Quaternion", () => {
+    describe("constructor", () => {
+        it("creates quaternion with x, y, z, w components", () => {
+            const q = new Quaternion(1, 2, 3, 4);
+            expect(q.x).toBe(1);
+            expect(q.y).toBe(2);
+            expect(q.z).toBe(3);
+            expect(q.w).toBe(4);
+        });
+    });
+    describe("identity", () => {
+        it("returns identity quaternion (0,0,0,1)", () => {
+            const q = Quaternion.identity();
+            expect(q.x).toBe(0);
+            expect(q.y).toBe(0);
+            expect(q.z).toBe(0);
+            expect(q.w).toBe(1);
+        });
+    });
+    describe("length", () => {
+        it("computes length correctly", () => {
+            const q = new Quaternion(1, 2, 2, 0);
+            expect(q.length()).toBe(3);
+        });
+        it("identity has length 1", () => {
+            const q = Quaternion.identity();
+            expect(q.length()).toBe(1);
+        });
+    });
+    describe("normalize", () => {
+        it("returns unit quaternion", () => {
+            const q = new Quaternion(1, 2, 3, 4);
+            const normalized = q.normalize();
+            expect(normalized.length()).toBeCloseTo(1);
+        });
+        it("returns identity for zero quaternion", () => {
+            const q = new Quaternion(0, 0, 0, 0);
+            const normalized = q.normalize();
+            expect(normalized.w).toBe(1);
+        });
+    });
+    describe("conjugate", () => {
+        it("negates xyz, keeps w", () => {
+            const q = new Quaternion(1, 2, 3, 4);
+            const conj = q.conjugate();
+            expect(conj.x).toBe(-1);
+            expect(conj.y).toBe(-2);
+            expect(conj.z).toBe(-3);
+            expect(conj.w).toBe(4);
+        });
+    });
+    describe("inverse", () => {
+        it("returns inverse quaternion", () => {
+            const q = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 4);
+            const inv = q.inverse();
+            const result = q.multiply(inv);
+            expect(result.x).toBeCloseTo(0);
+            expect(result.y).toBeCloseTo(0);
+            expect(result.z).toBeCloseTo(0);
+            expect(result.w).toBeCloseTo(1);
+        });
+    });
+    describe("multiply", () => {
+        it("identity * q = q", () => {
+            const q = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 4);
+            const result = Quaternion.identity().multiply(q);
+            expect(result.equals(q, 1e-10)).toBe(true);
+        });
+        it("q * identity = q", () => {
+            const q = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 4);
+            const result = q.multiply(Quaternion.identity());
+            expect(result.equals(q, 1e-10)).toBe(true);
+        });
+        it("combines rotations correctly", () => {
+            const q1 = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 2);
+            const q2 = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 2);
+            const combined = q1.multiply(q2);
+            // Combined should be 180 degree rotation around Z
+            const v = new Vector3d(1, 0, 0);
+            const rotated = combined.rotateVector(v);
+            expect(rotated.x).toBeCloseTo(-1);
+            expect(rotated.y).toBeCloseTo(0);
+            expect(rotated.z).toBeCloseTo(0);
+        });
+    });
+    describe("rotateVector", () => {
+        it("rotates vector around Z axis", () => {
+            const q = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 2);
+            const v = new Vector3d(1, 0, 0);
+            const result = q.rotateVector(v);
+            expect(result.x).toBeCloseTo(0);
+            expect(result.y).toBeCloseTo(1);
+            expect(result.z).toBeCloseTo(0);
+        });
+        it("rotates vector around X axis", () => {
+            const q = Quaternion.fromAxisAngle(Vector3d.unitX(), Math.PI / 2);
+            const v = new Vector3d(0, 1, 0);
+            const result = q.rotateVector(v);
+            expect(result.x).toBeCloseTo(0);
+            expect(result.y).toBeCloseTo(0);
+            expect(result.z).toBeCloseTo(1);
+        });
+        it("rotates vector around Y axis", () => {
+            const q = Quaternion.fromAxisAngle(Vector3d.unitY(), Math.PI / 2);
+            const v = new Vector3d(1, 0, 0);
+            const result = q.rotateVector(v);
+            expect(result.x).toBeCloseTo(0);
+            expect(result.y).toBeCloseTo(0);
+            expect(result.z).toBeCloseTo(-1);
+        });
+        it("identity does not rotate", () => {
+            const q = Quaternion.identity();
+            const v = new Vector3d(1, 2, 3);
+            const result = q.rotateVector(v);
+            expect(result.x).toBeCloseTo(1);
+            expect(result.y).toBeCloseTo(2);
+            expect(result.z).toBeCloseTo(3);
+        });
+    });
+    describe("fromAxisAngle", () => {
+        it("creates quaternion from axis and angle", () => {
+            const q = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI);
+            const v = new Vector3d(1, 0, 0);
+            const rotated = q.rotateVector(v);
+            expect(rotated.x).toBeCloseTo(-1);
+            expect(rotated.y).toBeCloseTo(0);
+        });
+        it("zero angle gives identity", () => {
+            const q = Quaternion.fromAxisAngle(Vector3d.unitZ(), 0);
+            expect(q.x).toBeCloseTo(0);
+            expect(q.y).toBeCloseTo(0);
+            expect(q.z).toBeCloseTo(0);
+            expect(q.w).toBeCloseTo(1);
+        });
+    });
+    describe("toAxisAngle", () => {
+        it("extracts axis and angle", () => {
+            const axis = new Vector3d(0, 0, 1);
+            const angle = Math.PI / 3;
+            const q = Quaternion.fromAxisAngle(axis, angle);
+            const result = q.toAxisAngle();
+            expect(result.angle).toBeCloseTo(angle);
+            expect(result.axis.x).toBeCloseTo(0);
+            expect(result.axis.y).toBeCloseTo(0);
+            expect(result.axis.z).toBeCloseTo(1);
+        });
+        it("handles identity quaternion", () => {
+            const q = Quaternion.identity();
+            const result = q.toAxisAngle();
+            expect(result.angle).toBeCloseTo(0);
+        });
+    });
+    describe("fromEulerAngles", () => {
+        it("creates quaternion from euler angles", () => {
+            const q = Quaternion.fromEulerAngles(0, 0, Math.PI / 2);
+            const v = new Vector3d(1, 0, 0);
+            const rotated = q.rotateVector(v);
+            expect(rotated.x).toBeCloseTo(0);
+            expect(rotated.y).toBeCloseTo(1);
+            expect(rotated.z).toBeCloseTo(0);
+        });
+        it("zero angles give identity", () => {
+            const q = Quaternion.fromEulerAngles(0, 0, 0);
+            expect(q.w).toBeCloseTo(1);
+            expect(q.x).toBeCloseTo(0);
+            expect(q.y).toBeCloseTo(0);
+            expect(q.z).toBeCloseTo(0);
+        });
+    });
+    describe("toEulerAngles", () => {
+        it("extracts euler angles", () => {
+            const q = Quaternion.fromEulerAngles(0.1, 0.2, 0.3);
+            const euler = q.toEulerAngles();
+            expect(euler.x).toBeCloseTo(0.1, 4);
+            expect(euler.y).toBeCloseTo(0.2, 4);
+            expect(euler.z).toBeCloseTo(0.3, 4);
+        });
+    });
+    describe("slerp", () => {
+        it("returns start at t=0", () => {
+            const q1 = Quaternion.fromAxisAngle(Vector3d.unitZ(), 0);
+            const q2 = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI);
+            const result = q1.slerp(q2, 0);
+            expect(result.equals(q1, 1e-10)).toBe(true);
+        });
+        it("returns end at t=1", () => {
+            const q1 = Quaternion.fromAxisAngle(Vector3d.unitZ(), 0);
+            const q2 = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 2);
+            const result = q1.slerp(q2, 1);
+            expect(result.x).toBeCloseTo(q2.x);
+            expect(result.y).toBeCloseTo(q2.y);
+            expect(result.z).toBeCloseTo(q2.z);
+            expect(result.w).toBeCloseTo(q2.w);
+        });
+        it("interpolates at t=0.5", () => {
+            const q1 = Quaternion.fromAxisAngle(Vector3d.unitZ(), 0);
+            const q2 = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 2);
+            const result = q1.slerp(q2, 0.5);
+            // Should be 45 degree rotation
+            const v = new Vector3d(1, 0, 0);
+            const rotated = result.rotateVector(v);
+            expect(rotated.x).toBeCloseTo(Math.cos(Math.PI / 4));
+            expect(rotated.y).toBeCloseTo(Math.sin(Math.PI / 4));
+        });
+    });
+    describe("equals", () => {
+        it("returns true for identical quaternions", () => {
+            const q1 = new Quaternion(1, 2, 3, 4);
+            const q2 = new Quaternion(1, 2, 3, 4);
+            expect(q1.equals(q2)).toBe(true);
+        });
+        it("returns false for different quaternions", () => {
+            const q1 = new Quaternion(1, 2, 3, 4);
+            const q2 = new Quaternion(1, 2, 3, 5);
+            expect(q1.equals(q2)).toBe(false);
+        });
+        it("supports tolerance", () => {
+            const q1 = new Quaternion(1, 2, 3, 4);
+            const q2 = new Quaternion(1.001, 2.001, 3.001, 4.001);
+            expect(q1.equals(q2, 0.01)).toBe(true);
+        });
+    });
+    describe("toMatrix", () => {
+        it("returns identity matrix for identity quaternion", () => {
+            const q = Quaternion.identity();
+            const m = q.toMatrix();
+            expect(m[0]).toBeCloseTo(1);
+            expect(m[5]).toBeCloseTo(1);
+            expect(m[10]).toBeCloseTo(1);
+            expect(m[15]).toBeCloseTo(1);
+        });
+        it("rotation matrix rotates correctly", () => {
+            const q = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 2);
+            const m = q.toMatrix();
+            // Apply matrix to vector (1,0,0)
+            const x = m[0] * 1 + m[4] * 0 + m[8] * 0;
+            const y = m[1] * 1 + m[5] * 0 + m[9] * 0;
+            const z = m[2] * 1 + m[6] * 0 + m[10] * 0;
+            expect(x).toBeCloseTo(0);
+            expect(y).toBeCloseTo(1);
+            expect(z).toBeCloseTo(0);
+        });
+    });
+    describe("fromRotationMatrix", () => {
+        it("reconstructs quaternion from its matrix", () => {
+            const original = Quaternion.fromAxisAngle(new Vector3d(1, 1, 1).normalize(), Math.PI / 3);
+            const matrix = original.toMatrix();
+            const reconstructed = Quaternion.fromRotationMatrix(matrix);
+            // Quaternions q and -q represent the same rotation
+            const sameRotation = original.equals(reconstructed, 1e-10) ||
+                original.equals(new Quaternion(-reconstructed.x, -reconstructed.y, -reconstructed.z, -reconstructed.w), 1e-10);
+            expect(sameRotation).toBe(true);
+        });
+    });
+    describe("dot", () => {
+        it("computes dot product", () => {
+            const q1 = new Quaternion(1, 0, 0, 0);
+            const q2 = new Quaternion(1, 0, 0, 0);
+            expect(q1.dot(q2)).toBe(1);
+        });
+        it("returns 0 for perpendicular quaternions", () => {
+            const q1 = new Quaternion(1, 0, 0, 0);
+            const q2 = new Quaternion(0, 1, 0, 0);
+            expect(q1.dot(q2)).toBe(0);
+        });
+    });
+    describe("clone", () => {
+        it("creates independent copy", () => {
+            const q = new Quaternion(1, 2, 3, 4);
+            const clone = q.clone();
+            expect(clone.equals(q)).toBe(true);
+            expect(clone).not.toBe(q);
+        });
+    });
+});

package/lib/dist/math/vector3d.d.ts

@@ -0,0 +1,43 @@
+import { Matrix4 } from "./matrix4.js";
+export declare class Vector3d {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    constructor(x: number, y: number, z: number);
+    equals(other: Vector3d, tolerance?: number): boolean;
+    dot(other: Vector3d): number;
+    cross(other: Vector3d): Vector3d;
+    isZero(tolerance?: number): boolean;
+    length(): number;
+    lengthSquared(): number;
+    normalize(): Vector3d;
+    add(other: Vector3d): Vector3d;
+    subtract(other: Vector3d): Vector3d;
+    multiply(scalar: number): Vector3d;
+    divide(scalar: number): Vector3d;
+    negate(): Vector3d;
+    reverse(): Vector3d;
+    distanceTo(other: Vector3d): number;
+    distanceToSquared(other: Vector3d): number;
+    angleTo(other: Vector3d): number;
+    projectOnto(other: Vector3d): Vector3d;
+    reflect(normal: Vector3d): Vector3d;
+    lerp(other: Vector3d, t: number): Vector3d;
+    transform(matrix: Matrix4): Vector3d;
+    clone(): Vector3d;
+    toArray(): [number, number, number];
+    toString(): string;
+    isParallelTo(other: Vector3d, tolerance?: number): boolean;
+    isPerpendicularTo(other: Vector3d, tolerance?: number): boolean;
+    static fromArray(arr: [number, number, number]): Vector3d;
+    static zero(): Vector3d;
+    static unitX(): Vector3d;
+    static unitY(): Vector3d;
+    static unitZ(): Vector3d;
+}
+export type Vector3dLike = Vector3d | [number, number, number] | {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare function normalizeVector(v: Vector3dLike): Vector3d;

package/lib/dist/math/vector3d.js

@@ -0,0 +1,143 @@
+export class Vector3d {
+    x;
+    y;
+    z;
+    constructor(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    equals(other, tolerance = 0) {
+        if (tolerance === 0) {
+            return this.x === other.x && this.y === other.y && this.z === other.z;
+        }
+        return (Math.abs(this.x - other.x) <= tolerance &&
+            Math.abs(this.y - other.y) <= tolerance &&
+            Math.abs(this.z - other.z) <= tolerance);
+    }
+    dot(other) {
+        return this.x * other.x + this.y * other.y + this.z * other.z;
+    }
+    cross(other) {
+        return new Vector3d(this.y * other.z - this.z * other.y, this.z * other.x - this.x * other.z, this.x * other.y - this.y * other.x);
+    }
+    isZero(tolerance = 0) {
+        if (tolerance === 0) {
+            return this.x === 0 && this.y === 0 && this.z === 0;
+        }
+        return this.length() <= tolerance;
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    }
+    lengthSquared() {
+        return this.x * this.x + this.y * this.y + this.z * this.z;
+    }
+    normalize() {
+        const len = this.length();
+        if (len === 0) {
+            throw new Error("Cannot normalize a zero vector");
+        }
+        return new Vector3d(this.x / len, this.y / len, this.z / len);
+    }
+    add(other) {
+        return new Vector3d(this.x + other.x, this.y + other.y, this.z + other.z);
+    }
+    subtract(other) {
+        return new Vector3d(this.x - other.x, this.y - other.y, this.z - other.z);
+    }
+    multiply(scalar) {
+        return new Vector3d(this.x * scalar, this.y * scalar, this.z * scalar);
+    }
+    divide(scalar) {
+        if (scalar === 0) {
+            throw new Error("Cannot divide by zero");
+        }
+        return new Vector3d(this.x / scalar, this.y / scalar, this.z / scalar);
+    }
+    negate() {
+        return new Vector3d(-this.x, -this.y, -this.z);
+    }
+    reverse() {
+        return new Vector3d(-this.x, -this.y, -this.z);
+    }
+    distanceTo(other) {
+        const dx = this.x - other.x;
+        const dy = this.y - other.y;
+        const dz = this.z - other.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    distanceToSquared(other) {
+        const dx = this.x - other.x;
+        const dy = this.y - other.y;
+        const dz = this.z - other.z;
+        return dx * dx + dy * dy + dz * dz;
+    }
+    angleTo(other) {
+        const denominator = Math.sqrt(this.lengthSquared() * other.lengthSquared());
+        if (denominator === 0) {
+            return Math.PI / 2;
+        }
+        const theta = this.dot(other) / denominator;
+        return Math.acos(Math.max(-1, Math.min(1, theta)));
+    }
+    projectOnto(other) {
+        const denominator = other.lengthSquared();
+        if (denominator === 0) {
+            return new Vector3d(0, 0, 0);
+        }
+        const scalar = this.dot(other) / denominator;
+        return other.multiply(scalar);
+    }
+    reflect(normal) {
+        const n = normal.normalize();
+        const dot2 = 2 * this.dot(n);
+        return this.subtract(n.multiply(dot2));
+    }
+    lerp(other, t) {
+        return new Vector3d(this.x + (other.x - this.x) * t, this.y + (other.y - this.y) * t, this.z + (other.z - this.z) * t);
+    }
+    transform(matrix) {
+        return matrix.transformVector(this);
+    }
+    clone() {
+        return new Vector3d(this.x, this.y, this.z);
+    }
+    toArray() {
+        return [this.x, this.y, this.z];
+    }
+    toString() {
+        return `Vector3d(${this.x}, ${this.y}, ${this.z})`;
+    }
+    isParallelTo(other, tolerance = 1e-10) {
+        const cross = this.cross(other);
+        return cross.lengthSquared() <= tolerance * tolerance;
+    }
+    isPerpendicularTo(other, tolerance = 1e-10) {
+        return Math.abs(this.dot(other)) <= tolerance;
+    }
+    static fromArray(arr) {
+        return new Vector3d(arr[0], arr[1], arr[2]);
+    }
+    static zero() {
+        return new Vector3d(0, 0, 0);
+    }
+    static unitX() {
+        return new Vector3d(1, 0, 0);
+    }
+    static unitY() {
+        return new Vector3d(0, 1, 0);
+    }
+    static unitZ() {
+        return new Vector3d(0, 0, 1);
+    }
+}
+export function normalizeVector(v) {
+    if (v instanceof Vector3d) {
+        return v;
+    }
+    if (Array.isArray(v)) {
+        return new Vector3d(v[0], v[1], v[2]);
+    }
+    return new Vector3d(v.x, v.y, v.z);
+}

package/lib/dist/math/vector3d.test.d.ts

@@ -0,0 +1 @@
+export {};