fluidcad 0.0.2

package/lib/dist/math/matrix4.js

@@ -0,0 +1,336 @@
+import { Vector3d } from "./vector3d.js";
+import { Point } from "./point.js";
+import { Quaternion } from "./quaternion.js";
+/**
+ * 4x4 transformation matrix stored in column-major order.
+ * Layout:
+ *   [0]  [4]  [8]  [12]     m00 m01 m02 m03
+ *   [1]  [5]  [9]  [13]  =  m10 m11 m12 m13
+ *   [2]  [6]  [10] [14]     m20 m21 m22 m23
+ *   [3]  [7]  [11] [15]     m30 m31 m32 m33
+ */
+export class Matrix4 {
+    elements;
+    constructor(elements) {
+        if (elements) {
+            if (elements.length !== 16) {
+                throw new Error("Matrix4 requires exactly 16 elements");
+            }
+            this.elements = Object.freeze([...elements]);
+        }
+        else {
+            this.elements = Object.freeze([
+                1, 0, 0, 0,
+                0, 1, 0, 0,
+                0, 0, 1, 0,
+                0, 0, 0, 1,
+            ]);
+        }
+    }
+    get(row, col) {
+        return this.elements[col * 4 + row];
+    }
+    multiply(other) {
+        const a = this.elements;
+        const b = other.elements;
+        const result = new Array(16);
+        for (let col = 0; col < 4; col++) {
+            for (let row = 0; row < 4; row++) {
+                result[col * 4 + row] =
+                    a[row] * b[col * 4] +
+                        a[4 + row] * b[col * 4 + 1] +
+                        a[8 + row] * b[col * 4 + 2] +
+                        a[12 + row] * b[col * 4 + 3];
+            }
+        }
+        return new Matrix4(result);
+    }
+    premultiply(other) {
+        return other.multiply(this);
+    }
+    determinant() {
+        const m = this.elements;
+        const n11 = m[0], n12 = m[4], n13 = m[8], n14 = m[12];
+        const n21 = m[1], n22 = m[5], n23 = m[9], n24 = m[13];
+        const n31 = m[2], n32 = m[6], n33 = m[10], n34 = m[14];
+        const n41 = m[3], n42 = m[7], n43 = m[11], n44 = m[15];
+        return (n41 * (n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 +
+            n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34) +
+            n42 * (n11 * n23 * n34 - n11 * n24 * n33 + n14 * n21 * n33 -
+                n13 * n21 * n34 + n13 * n24 * n31 - n14 * n23 * n31) +
+            n43 * (n11 * n24 * n32 - n11 * n22 * n34 - n14 * n21 * n32 +
+                n12 * n21 * n34 + n14 * n22 * n31 - n12 * n24 * n31) +
+            n44 * (-n13 * n22 * n31 - n11 * n23 * n32 + n11 * n22 * n33 +
+                n13 * n21 * n32 - n12 * n21 * n33 + n12 * n23 * n31));
+    }
+    inverse() {
+        const m = this.elements;
+        const result = new Array(16);
+        const n11 = m[0], n12 = m[4], n13 = m[8], n14 = m[12];
+        const n21 = m[1], n22 = m[5], n23 = m[9], n24 = m[13];
+        const n31 = m[2], n32 = m[6], n33 = m[10], n34 = m[14];
+        const n41 = m[3], n42 = m[7], n43 = m[11], n44 = m[15];
+        const t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44;
+        const t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44;
+        const t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44;
+        const t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
+        const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
+        if (det === 0) {
+            throw new Error("Matrix is not invertible (determinant is zero)");
+        }
+        const detInv = 1 / det;
+        result[0] = t11 * detInv;
+        result[1] = (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) * detInv;
+        result[2] = (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) * detInv;
+        result[3] = (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) * detInv;
+        result[4] = t12 * detInv;
+        result[5] = (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) * detInv;
+        result[6] = (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) * detInv;
+        result[7] = (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) * detInv;
+        result[8] = t13 * detInv;
+        result[9] = (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) * detInv;
+        result[10] = (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) * detInv;
+        result[11] = (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) * detInv;
+        result[12] = t14 * detInv;
+        result[13] = (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) * detInv;
+        result[14] = (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) * detInv;
+        result[15] = (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) * detInv;
+        return new Matrix4(result);
+    }
+    transpose() {
+        const m = this.elements;
+        return new Matrix4([
+            m[0], m[4], m[8], m[12],
+            m[1], m[5], m[9], m[13],
+            m[2], m[6], m[10], m[14],
+            m[3], m[7], m[11], m[15],
+        ]);
+    }
+    transformPoint(p) {
+        const m = this.elements;
+        const x = p.x, y = p.y, z = p.z;
+        const w = 1 / (m[3] * x + m[7] * y + m[11] * z + m[15]);
+        return new Point((m[0] * x + m[4] * y + m[8] * z + m[12]) * w, (m[1] * x + m[5] * y + m[9] * z + m[13]) * w, (m[2] * x + m[6] * y + m[10] * z + m[14]) * w);
+    }
+    transformVector(v) {
+        const m = this.elements;
+        const x = v.x, y = v.y, z = v.z;
+        return new Vector3d(m[0] * x + m[4] * y + m[8] * z, m[1] * x + m[5] * y + m[9] * z, m[2] * x + m[6] * y + m[10] * z);
+    }
+    transformDirection(v) {
+        return this.transformVector(v).normalize();
+    }
+    decompose() {
+        const m = this.elements;
+        const sx = new Vector3d(m[0], m[1], m[2]).length();
+        const sy = new Vector3d(m[4], m[5], m[6]).length();
+        const sz = new Vector3d(m[8], m[9], m[10]).length();
+        const det = this.determinant();
+        const signX = det < 0 ? -1 : 1;
+        const translation = new Vector3d(m[12], m[13], m[14]);
+        const scale = new Vector3d(sx * signX, sy, sz);
+        const invSX = 1 / sx;
+        const invSY = 1 / sy;
+        const invSZ = 1 / sz;
+        const rotationMatrix = [
+            m[0] * invSX, m[1] * invSX, m[2] * invSX, 0,
+            m[4] * invSY, m[5] * invSY, m[6] * invSY, 0,
+            m[8] * invSZ, m[9] * invSZ, m[10] * invSZ, 0,
+            0, 0, 0, 1,
+        ];
+        const rotation = Quaternion.fromRotationMatrix(rotationMatrix);
+        return { translation, rotation, scale };
+    }
+    isMirroring() {
+        return this.determinant() < 0;
+    }
+    equals(other, tolerance = 0) {
+        for (let i = 0; i < 16; i++) {
+            if (tolerance === 0) {
+                if (this.elements[i] !== other.elements[i])
+                    return false;
+            }
+            else {
+                if (Math.abs(this.elements[i] - other.elements[i]) > tolerance)
+                    return false;
+            }
+        }
+        return true;
+    }
+    clone() {
+        return new Matrix4([...this.elements]);
+    }
+    toArray() {
+        return [...this.elements];
+    }
+    toString() {
+        const m = this.elements;
+        return `Matrix4(\n  ${m[0]}, ${m[4]}, ${m[8]}, ${m[12]}\n  ${m[1]}, ${m[5]}, ${m[9]}, ${m[13]}\n  ${m[2]}, ${m[6]}, ${m[10]}, ${m[14]}\n  ${m[3]}, ${m[7]}, ${m[11]}, ${m[15]}\n)`;
+    }
+    static identity() {
+        return new Matrix4();
+    }
+    static fromTranslation(x, y, z) {
+        return new Matrix4([
+            1, 0, 0, 0,
+            0, 1, 0, 0,
+            0, 0, 1, 0,
+            x, y, z, 1,
+        ]);
+    }
+    static fromTranslationVector(v) {
+        return Matrix4.fromTranslation(v.x, v.y, v.z);
+    }
+    static fromScale(x, y, z) {
+        return new Matrix4([
+            x, 0, 0, 0,
+            0, y, 0, 0,
+            0, 0, z, 0,
+            0, 0, 0, 1,
+        ]);
+    }
+    static fromUniformScale(s) {
+        return Matrix4.fromScale(s, s, s);
+    }
+    static fromRotationX(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        return new Matrix4([
+            1, 0, 0, 0,
+            0, c, s, 0,
+            0, -s, c, 0,
+            0, 0, 0, 1,
+        ]);
+    }
+    static fromRotationY(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        return new Matrix4([
+            c, 0, -s, 0,
+            0, 1, 0, 0,
+            s, 0, c, 0,
+            0, 0, 0, 1,
+        ]);
+    }
+    static fromRotationZ(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        return new Matrix4([
+            c, s, 0, 0,
+            -s, c, 0, 0,
+            0, 0, 1, 0,
+            0, 0, 0, 1,
+        ]);
+    }
+    static fromAxisAngle(axis, angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const t = 1 - c;
+        const n = axis.normalize();
+        const x = n.x, y = n.y, z = n.z;
+        return new Matrix4([
+            t * x * x + c, t * x * y + s * z, t * x * z - s * y, 0,
+            t * x * y - s * z, t * y * y + c, t * y * z + s * x, 0,
+            t * x * z + s * y, t * y * z - s * x, t * z * z + c, 0,
+            0, 0, 0, 1,
+        ]);
+    }
+    static fromRotationAroundAxis(origin, direction, angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const t = 1 - c;
+        const n = direction.normalize();
+        const x = n.x, y = n.y, z = n.z;
+        const px = origin.x, py = origin.y, pz = origin.z;
+        const r00 = t * x * x + c;
+        const r10 = t * x * y + s * z;
+        const r20 = t * x * z - s * y;
+        const r01 = t * x * y - s * z;
+        const r11 = t * y * y + c;
+        const r21 = t * y * z + s * x;
+        const r02 = t * x * z + s * y;
+        const r12 = t * y * z - s * x;
+        const r22 = t * z * z + c;
+        const tx = px - (r00 * px + r01 * py + r02 * pz);
+        const ty = py - (r10 * px + r11 * py + r12 * pz);
+        const tz = pz - (r20 * px + r21 * py + r22 * pz);
+        return new Matrix4([
+            r00, r10, r20, 0,
+            r01, r11, r21, 0,
+            r02, r12, r22, 0,
+            tx, ty, tz, 1,
+        ]);
+    }
+    static fromQuaternion(q) {
+        return new Matrix4(q.toMatrix());
+    }
+    static fromEulerAngles(x, y, z) {
+        const q = Quaternion.fromEulerAngles(x, y, z);
+        return Matrix4.fromQuaternion(q);
+    }
+    static fromBasis(xAxis, yAxis, zAxis, origin = Point.origin()) {
+        return new Matrix4([
+            xAxis.x, xAxis.y, xAxis.z, 0,
+            yAxis.x, yAxis.y, yAxis.z, 0,
+            zAxis.x, zAxis.y, zAxis.z, 0,
+            origin.x, origin.y, origin.z, 1,
+        ]);
+    }
+    static compose(translation, rotation, scale) {
+        const rotMatrix = Matrix4.fromQuaternion(rotation);
+        const scaleMatrix = Matrix4.fromScale(scale.x, scale.y, scale.z);
+        const translationMatrix = Matrix4.fromTranslationVector(translation);
+        return translationMatrix.multiply(rotMatrix).multiply(scaleMatrix);
+    }
+    static lookAt(eye, target, up = Vector3d.unitY()) {
+        const zAxis = eye.vectorTo(target).normalize().negate();
+        const xAxis = up.cross(zAxis).normalize();
+        const yAxis = zAxis.cross(xAxis);
+        return new Matrix4([
+            xAxis.x, yAxis.x, zAxis.x, 0,
+            xAxis.y, yAxis.y, zAxis.y, 0,
+            xAxis.z, yAxis.z, zAxis.z, 0,
+            -xAxis.dot(eye.toVector3d()), -yAxis.dot(eye.toVector3d()), -zAxis.dot(eye.toVector3d()), 1,
+        ]);
+    }
+    static mirrorPoint(point) {
+        const px = point.x, py = point.y, pz = point.z;
+        return new Matrix4([
+            -1, 0, 0, 0,
+            0, -1, 0, 0,
+            0, 0, -1, 0,
+            2 * px, 2 * py, 2 * pz, 1,
+        ]);
+    }
+    static mirrorPlane(normal, pointOnPlane) {
+        const n = normal.normalize();
+        const d = -n.dot(pointOnPlane.toVector3d());
+        const a = n.x, b = n.y, c = n.z;
+        return new Matrix4([
+            1 - 2 * a * a, -2 * a * b, -2 * a * c, 0,
+            -2 * a * b, 1 - 2 * b * b, -2 * b * c, 0,
+            -2 * a * c, -2 * b * c, 1 - 2 * c * c, 0,
+            -2 * a * d, -2 * b * d, -2 * c * d, 1,
+        ]);
+    }
+    static mirrorAxis(axisOrigin, axisDirection) {
+        const d = axisDirection.normalize();
+        const p = axisOrigin;
+        const dx = d.x, dy = d.y, dz = d.z;
+        const px = p.x, py = p.y, pz = p.z;
+        const xx = dx * dx, yy = dy * dy, zz = dz * dz;
+        const xy = dx * dy, xz = dx * dz, yz = dy * dz;
+        return new Matrix4([
+            2 * xx - 1, 2 * xy, 2 * xz, 0,
+            2 * xy, 2 * yy - 1, 2 * yz, 0,
+            2 * xz, 2 * yz, 2 * zz - 1, 0,
+            2 * (px - xx * px - xy * py - xz * pz),
+            2 * (py - xy * px - yy * py - yz * pz),
+            2 * (pz - xz * px - yz * py - zz * pz),
+            1,
+        ]);
+    }
+    static fromArray(arr) {
+        return new Matrix4(arr);
+    }
+}

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

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

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

@@ -0,0 +1,357 @@
+import { describe, it, expect } from "vitest";
+import { Matrix4 } from "./matrix4.js";
+import { Vector3d } from "./vector3d.js";
+import { Point } from "./point.js";
+import { Quaternion } from "./quaternion.js";
+describe("Matrix4", () => {
+    describe("constructor", () => {
+        it("creates identity matrix by default", () => {
+            const m = new Matrix4();
+            expect(m.get(0, 0)).toBe(1);
+            expect(m.get(1, 1)).toBe(1);
+            expect(m.get(2, 2)).toBe(1);
+            expect(m.get(3, 3)).toBe(1);
+            expect(m.get(0, 1)).toBe(0);
+        });
+        it("creates matrix from array", () => {
+            const elements = [
+                1, 2, 3, 4,
+                5, 6, 7, 8,
+                9, 10, 11, 12,
+                13, 14, 15, 16,
+            ];
+            const m = new Matrix4(elements);
+            expect(m.get(0, 0)).toBe(1);
+            expect(m.get(1, 0)).toBe(2);
+            expect(m.get(0, 1)).toBe(5);
+        });
+        it("throws for wrong array length", () => {
+            expect(() => new Matrix4([1, 2, 3])).toThrow();
+        });
+    });
+    describe("identity", () => {
+        it("returns identity matrix", () => {
+            const m = Matrix4.identity();
+            expect(m.get(0, 0)).toBe(1);
+            expect(m.get(1, 1)).toBe(1);
+            expect(m.get(2, 2)).toBe(1);
+            expect(m.get(3, 3)).toBe(1);
+        });
+    });
+    describe("multiply", () => {
+        it("identity * M = M", () => {
+            const m = Matrix4.fromTranslation(1, 2, 3);
+            const result = Matrix4.identity().multiply(m);
+            expect(result.equals(m)).toBe(true);
+        });
+        it("M * identity = M", () => {
+            const m = Matrix4.fromTranslation(1, 2, 3);
+            const result = m.multiply(Matrix4.identity());
+            expect(result.equals(m)).toBe(true);
+        });
+        it("combines translations correctly", () => {
+            const t1 = Matrix4.fromTranslation(1, 0, 0);
+            const t2 = Matrix4.fromTranslation(0, 2, 0);
+            const combined = t1.multiply(t2);
+            const p = combined.transformPoint(Point.origin());
+            expect(p.x).toBeCloseTo(1);
+            expect(p.y).toBeCloseTo(2);
+            expect(p.z).toBeCloseTo(0);
+        });
+    });
+    describe("determinant", () => {
+        it("identity has determinant 1", () => {
+            const m = Matrix4.identity();
+            expect(m.determinant()).toBe(1);
+        });
+        it("scale matrix has determinant = product of scales", () => {
+            const m = Matrix4.fromScale(2, 3, 4);
+            expect(m.determinant()).toBeCloseTo(24);
+        });
+    });
+    describe("inverse", () => {
+        it("M * M^-1 = identity", () => {
+            const m = Matrix4.fromTranslation(1, 2, 3);
+            const inv = m.inverse();
+            const result = m.multiply(inv);
+            expect(result.equals(Matrix4.identity(), 1e-10)).toBe(true);
+        });
+        it("inverts rotation matrix", () => {
+            const m = Matrix4.fromRotationZ(Math.PI / 4);
+            const inv = m.inverse();
+            const result = m.multiply(inv);
+            expect(result.equals(Matrix4.identity(), 1e-10)).toBe(true);
+        });
+        it("inverts complex transformation", () => {
+            const m = Matrix4.fromTranslation(1, 2, 3)
+                .multiply(Matrix4.fromRotationY(Math.PI / 6))
+                .multiply(Matrix4.fromScale(2, 2, 2));
+            const inv = m.inverse();
+            const result = m.multiply(inv);
+            expect(result.equals(Matrix4.identity(), 1e-10)).toBe(true);
+        });
+    });
+    describe("transpose", () => {
+        it("swaps rows and columns", () => {
+            const m = new Matrix4([
+                1, 2, 3, 4,
+                5, 6, 7, 8,
+                9, 10, 11, 12,
+                13, 14, 15, 16,
+            ]);
+            const t = m.transpose();
+            expect(t.get(0, 1)).toBe(m.get(1, 0));
+            expect(t.get(1, 0)).toBe(m.get(0, 1));
+        });
+        it("double transpose returns original", () => {
+            const m = Matrix4.fromRotationZ(Math.PI / 4);
+            const result = m.transpose().transpose();
+            expect(result.equals(m, 1e-10)).toBe(true);
+        });
+    });
+    describe("fromTranslation", () => {
+        it("creates translation matrix", () => {
+            const m = Matrix4.fromTranslation(10, 20, 30);
+            const p = m.transformPoint(Point.origin());
+            expect(p.x).toBe(10);
+            expect(p.y).toBe(20);
+            expect(p.z).toBe(30);
+        });
+        it("does not affect vectors", () => {
+            const m = Matrix4.fromTranslation(10, 20, 30);
+            const v = m.transformVector(new Vector3d(1, 0, 0));
+            expect(v.x).toBe(1);
+            expect(v.y).toBe(0);
+            expect(v.z).toBe(0);
+        });
+    });
+    describe("fromScale", () => {
+        it("creates scale matrix", () => {
+            const m = Matrix4.fromScale(2, 3, 4);
+            const p = m.transformPoint(new Point(1, 1, 1));
+            expect(p.x).toBe(2);
+            expect(p.y).toBe(3);
+            expect(p.z).toBe(4);
+        });
+        it("scales vectors", () => {
+            const m = Matrix4.fromScale(2, 3, 4);
+            const v = m.transformVector(new Vector3d(1, 1, 1));
+            expect(v.x).toBe(2);
+            expect(v.y).toBe(3);
+            expect(v.z).toBe(4);
+        });
+    });
+    describe("fromUniformScale", () => {
+        it("scales uniformly", () => {
+            const m = Matrix4.fromUniformScale(3);
+            const p = m.transformPoint(new Point(1, 2, 3));
+            expect(p.x).toBe(3);
+            expect(p.y).toBe(6);
+            expect(p.z).toBe(9);
+        });
+    });
+    describe("fromRotationX", () => {
+        it("rotates around X axis", () => {
+            const m = Matrix4.fromRotationX(Math.PI / 2);
+            const p = m.transformPoint(new Point(0, 1, 0));
+            expect(p.x).toBeCloseTo(0);
+            expect(p.y).toBeCloseTo(0);
+            expect(p.z).toBeCloseTo(1);
+        });
+    });
+    describe("fromRotationY", () => {
+        it("rotates around Y axis", () => {
+            const m = Matrix4.fromRotationY(Math.PI / 2);
+            const p = m.transformPoint(new Point(1, 0, 0));
+            expect(p.x).toBeCloseTo(0);
+            expect(p.y).toBeCloseTo(0);
+            expect(p.z).toBeCloseTo(-1);
+        });
+    });
+    describe("fromRotationZ", () => {
+        it("rotates around Z axis", () => {
+            const m = Matrix4.fromRotationZ(Math.PI / 2);
+            const p = m.transformPoint(new Point(1, 0, 0));
+            expect(p.x).toBeCloseTo(0);
+            expect(p.y).toBeCloseTo(1);
+            expect(p.z).toBeCloseTo(0);
+        });
+    });
+    describe("fromAxisAngle", () => {
+        it("rotates around arbitrary axis", () => {
+            const m = Matrix4.fromAxisAngle(Vector3d.unitZ(), Math.PI / 2);
+            const p = m.transformPoint(new Point(1, 0, 0));
+            expect(p.x).toBeCloseTo(0);
+            expect(p.y).toBeCloseTo(1);
+            expect(p.z).toBeCloseTo(0);
+        });
+        it("rotates around diagonal axis", () => {
+            const axis = new Vector3d(1, 1, 0).normalize();
+            const m = Matrix4.fromAxisAngle(axis, Math.PI);
+            const p = m.transformPoint(new Point(1, 0, 0));
+            expect(p.x).toBeCloseTo(0);
+            expect(p.y).toBeCloseTo(1);
+            expect(p.z).toBeCloseTo(0);
+        });
+    });
+    describe("fromQuaternion", () => {
+        it("creates rotation matrix from quaternion", () => {
+            const q = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 2);
+            const m = Matrix4.fromQuaternion(q);
+            const p = m.transformPoint(new Point(1, 0, 0));
+            expect(p.x).toBeCloseTo(0);
+            expect(p.y).toBeCloseTo(1);
+            expect(p.z).toBeCloseTo(0);
+        });
+    });
+    describe("fromEulerAngles", () => {
+        it("creates rotation from euler angles", () => {
+            const m = Matrix4.fromEulerAngles(0, 0, Math.PI / 2);
+            const p = m.transformPoint(new Point(1, 0, 0));
+            expect(p.x).toBeCloseTo(0);
+            expect(p.y).toBeCloseTo(1);
+            expect(p.z).toBeCloseTo(0);
+        });
+    });
+    describe("mirrorPoint", () => {
+        it("mirrors through a point", () => {
+            const m = Matrix4.mirrorPoint(new Point(5, 0, 0));
+            const p = m.transformPoint(new Point(3, 0, 0));
+            expect(p.x).toBeCloseTo(7);
+            expect(p.y).toBeCloseTo(0);
+            expect(p.z).toBeCloseTo(0);
+        });
+        it("mirrors through origin", () => {
+            const m = Matrix4.mirrorPoint(Point.origin());
+            const p = m.transformPoint(new Point(1, 2, 3));
+            expect(p.x).toBeCloseTo(-1);
+            expect(p.y).toBeCloseTo(-2);
+            expect(p.z).toBeCloseTo(-3);
+        });
+    });
+    describe("mirrorPlane", () => {
+        it("mirrors through XY plane", () => {
+            const m = Matrix4.mirrorPlane(Vector3d.unitZ(), Point.origin());
+            const p = m.transformPoint(new Point(1, 2, 3));
+            expect(p.x).toBeCloseTo(1);
+            expect(p.y).toBeCloseTo(2);
+            expect(p.z).toBeCloseTo(-3);
+        });
+        it("mirrors through YZ plane", () => {
+            const m = Matrix4.mirrorPlane(Vector3d.unitX(), Point.origin());
+            const p = m.transformPoint(new Point(1, 2, 3));
+            expect(p.x).toBeCloseTo(-1);
+            expect(p.y).toBeCloseTo(2);
+            expect(p.z).toBeCloseTo(3);
+        });
+        it("mirrors through offset plane", () => {
+            const m = Matrix4.mirrorPlane(Vector3d.unitX(), new Point(5, 0, 0));
+            const p = m.transformPoint(new Point(3, 0, 0));
+            expect(p.x).toBeCloseTo(7);
+        });
+    });
+    describe("mirrorAxis", () => {
+        it("mirrors through Z axis", () => {
+            const m = Matrix4.mirrorAxis(Point.origin(), Vector3d.unitZ());
+            const p = m.transformPoint(new Point(1, 0, 0));
+            expect(p.x).toBeCloseTo(-1);
+            expect(p.y).toBeCloseTo(0);
+            expect(p.z).toBeCloseTo(0);
+        });
+        it("mirrors through offset axis", () => {
+            const m = Matrix4.mirrorAxis(new Point(5, 0, 0), Vector3d.unitZ());
+            const p = m.transformPoint(new Point(3, 0, 0));
+            expect(p.x).toBeCloseTo(7);
+            expect(p.y).toBeCloseTo(0);
+        });
+    });
+    describe("transformPoint", () => {
+        it("applies translation", () => {
+            const m = Matrix4.fromTranslation(10, 20, 30);
+            const p = m.transformPoint(new Point(1, 2, 3));
+            expect(p.x).toBe(11);
+            expect(p.y).toBe(22);
+            expect(p.z).toBe(33);
+        });
+    });
+    describe("transformVector", () => {
+        it("applies rotation but not translation", () => {
+            const m = Matrix4.fromTranslation(10, 20, 30)
+                .multiply(Matrix4.fromRotationZ(Math.PI / 2));
+            const v = m.transformVector(new Vector3d(1, 0, 0));
+            expect(v.x).toBeCloseTo(0);
+            expect(v.y).toBeCloseTo(1);
+            expect(v.z).toBeCloseTo(0);
+        });
+    });
+    describe("transformDirection", () => {
+        it("returns normalized result", () => {
+            const m = Matrix4.fromScale(2, 2, 2);
+            const d = m.transformDirection(new Vector3d(1, 0, 0));
+            expect(d.length()).toBeCloseTo(1);
+        });
+    });
+    describe("decompose", () => {
+        it("extracts translation", () => {
+            const m = Matrix4.fromTranslation(1, 2, 3);
+            const { translation } = m.decompose();
+            expect(translation.x).toBeCloseTo(1);
+            expect(translation.y).toBeCloseTo(2);
+            expect(translation.z).toBeCloseTo(3);
+        });
+        it("extracts scale", () => {
+            const m = Matrix4.fromScale(2, 3, 4);
+            const { scale } = m.decompose();
+            expect(scale.x).toBeCloseTo(2);
+            expect(scale.y).toBeCloseTo(3);
+            expect(scale.z).toBeCloseTo(4);
+        });
+        it("extracts rotation", () => {
+            const m = Matrix4.fromRotationZ(Math.PI / 4);
+            const { rotation } = m.decompose();
+            const v = rotation.rotateVector(new Vector3d(1, 0, 0));
+            expect(v.x).toBeCloseTo(Math.cos(Math.PI / 4));
+            expect(v.y).toBeCloseTo(Math.sin(Math.PI / 4));
+        });
+    });
+    describe("compose", () => {
+        it("creates matrix from translation, rotation, scale", () => {
+            const translation = new Vector3d(10, 20, 30);
+            const rotation = Quaternion.fromAxisAngle(Vector3d.unitZ(), Math.PI / 2);
+            const scale = new Vector3d(2, 2, 2);
+            const m = Matrix4.compose(translation, rotation, scale);
+            const p = m.transformPoint(new Point(1, 0, 0));
+            // First scale (1,0,0) -> (2,0,0)
+            // Then rotate 90° around Z -> (0,2,0)
+            // Then translate -> (10,22,30)
+            expect(p.x).toBeCloseTo(10);
+            expect(p.y).toBeCloseTo(22);
+            expect(p.z).toBeCloseTo(30);
+        });
+    });
+    describe("equals", () => {
+        it("returns true for identical matrices", () => {
+            const m1 = Matrix4.fromTranslation(1, 2, 3);
+            const m2 = Matrix4.fromTranslation(1, 2, 3);
+            expect(m1.equals(m2)).toBe(true);
+        });
+        it("returns false for different matrices", () => {
+            const m1 = Matrix4.fromTranslation(1, 2, 3);
+            const m2 = Matrix4.fromTranslation(1, 2, 4);
+            expect(m1.equals(m2)).toBe(false);
+        });
+        it("supports tolerance", () => {
+            const m1 = Matrix4.fromTranslation(1, 2, 3);
+            const m2 = Matrix4.fromTranslation(1.001, 2.001, 3.001);
+            expect(m1.equals(m2, 0.01)).toBe(true);
+        });
+    });
+    describe("clone", () => {
+        it("creates independent copy", () => {
+            const m = Matrix4.fromTranslation(1, 2, 3);
+            const clone = m.clone();
+            expect(clone.equals(m)).toBe(true);
+            expect(clone).not.toBe(m);
+        });
+    });
+});