@pawells/math-extended 1.0.1

package/build/matrices/transformations.spec.js

@@ -0,0 +1,755 @@
+import { MatrixRotation2D, MatrixRotation3DRoll, MatrixRotation3DPitch, MatrixRotation3DYaw, MatrixRotation3D, MatrixRotation3DEulerAngles, MatrixScale2D, MatrixScale3D, MatrixTranslation2D, MatrixTranslation3D, MatrixTransform2D, MatrixTransform3D, MatrixDirection3D, MatrixView, MatrixPerspective, MatrixOrthographic, } from './transformations.js';
+import { DegreesToRadians } from '../angles.ts';
+import { AssertMatrixRow, AssertMatrixValue } from './asserts.js';
+import { MatrixIdentity } from './core.js';
+import { VectorMagnitude } from '../vectors/core.ts';
+describe('Matrix Transformations', () => {
+    // Helper function to check if matrices are approximately equal
+    function expectMatrixToBeCloseTo(actual, expected, precision = 5) {
+        expect(actual.length).toBe(expected.length);
+        for (let i = 0; i < actual.length; i++) {
+            const actualRow = actual[i];
+            expect(actualRow).toBeDefined();
+            AssertMatrixRow(actualRow);
+            const expectedRow = expected[i];
+            expect(expectedRow).toBeDefined();
+            AssertMatrixRow(expectedRow);
+            const actualRowLength = actualRow.length;
+            const expectedRowLength = expectedRow.length;
+            expect(actualRowLength).toBe(expectedRowLength);
+            for (let j = 0; j < actualRow.length; j++) {
+                const actualValue = actualRow[j];
+                AssertMatrixValue(actualValue);
+                const expectedValue = expectedRow[j];
+                AssertMatrixValue(expectedValue);
+                expect(actualValue).toBeCloseTo(expectedValue, precision);
+            }
+        }
+    }
+    describe('2D Rotation', () => {
+        describe('MatrixRotation2D', () => {
+            test('should create identity matrix for 0 radians', () => {
+                const matrix = MatrixRotation2D(0);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0],
+                    [0, 1, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should create 90-degree rotation matrix', () => {
+                const matrix = MatrixRotation2D(Math.PI / 2);
+                expectMatrixToBeCloseTo(matrix, [
+                    [0, -1, 0],
+                    [1, 0, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should create 180-degree rotation matrix', () => {
+                const matrix = MatrixRotation2D(Math.PI);
+                expectMatrixToBeCloseTo(matrix, [
+                    [-1, 0, 0],
+                    [0, -1, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should create 270-degree rotation matrix', () => {
+                const matrix = MatrixRotation2D(3 * Math.PI / 2);
+                expectMatrixToBeCloseTo(matrix, [
+                    [0, 1, 0],
+                    [-1, 0, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should handle negative angles', () => {
+                const matrix = MatrixRotation2D(-Math.PI / 2);
+                expectMatrixToBeCloseTo(matrix, [
+                    [0, 1, 0],
+                    [-1, 0, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should throw for invalid input', () => {
+                // @ts-expect-error Argument of type 'string' is not assignable to parameter of type 'number'. This should throw at runtime.
+                expect(() => MatrixRotation2D('invalid')).toThrow('Rotation angle must be a number');
+                expect(() => MatrixRotation2D(NaN)).toThrow('Rotation angle must be a number');
+                expect(() => MatrixRotation2D(Infinity)).toThrow('Rotation angle must be a number');
+            });
+        });
+    });
+    describe('3D Rotations', () => {
+        describe('MatrixRotation3DRoll', () => {
+            test('should create identity matrix for 0 radians', () => {
+                const matrix = MatrixRotation3DRoll(0);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should create 90-degree roll rotation', () => {
+                const matrix = MatrixRotation3DRoll(Math.PI / 2);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 0],
+                    [0, 0, -1, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should throw for invalid input', () => {
+                expect(() => MatrixRotation3DRoll(NaN)).toThrow('Rotation angle must be a number');
+            });
+        });
+        describe('MatrixRotation3DPitch', () => {
+            test('should create identity matrix for 0 radians', () => {
+                const matrix = MatrixRotation3DPitch(0);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should create 90-degree pitch rotation', () => {
+                const matrix = MatrixRotation3DPitch(Math.PI / 2);
+                expectMatrixToBeCloseTo(matrix, [
+                    [0, 0, 1, 0],
+                    [0, 1, 0, 0],
+                    [-1, 0, 0, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should throw for invalid input', () => {
+                expect(() => MatrixRotation3DPitch(NaN)).toThrow('Rotation angle must be a number');
+            });
+        });
+        describe('MatrixRotation3DYaw', () => {
+            test('should create identity matrix for 0 radians', () => {
+                const matrix = MatrixRotation3DYaw(0);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should create 90-degree yaw rotation', () => {
+                const matrix = MatrixRotation3DYaw(Math.PI / 2);
+                expectMatrixToBeCloseTo(matrix, [
+                    [0, -1, 0, 0],
+                    [1, 0, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should throw for invalid input', () => {
+                expect(() => MatrixRotation3DYaw(NaN)).toThrow('Rotation angle must be a number');
+            });
+        });
+        describe('MatrixRotation3D', () => {
+            test('should create identity matrix for zero rotation', () => {
+                const matrix = MatrixRotation3D(0, 0, 0);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should handle single axis rotations', () => {
+                const rollMatrix = MatrixRotation3D(Math.PI / 2, 0, 0);
+                const expectedRoll = MatrixRotation3DRoll(Math.PI / 2);
+                expectMatrixToBeCloseTo(rollMatrix, expectedRoll);
+                const pitchMatrix = MatrixRotation3D(0, Math.PI / 2, 0);
+                const expectedPitch = MatrixRotation3DPitch(Math.PI / 2);
+                expectMatrixToBeCloseTo(pitchMatrix, expectedPitch);
+                const yawMatrix = MatrixRotation3D(0, 0, Math.PI / 2);
+                const expectedYaw = MatrixRotation3DYaw(Math.PI / 2);
+                expectMatrixToBeCloseTo(yawMatrix, expectedYaw);
+            });
+            test('should create complex rotation with all axes', () => {
+                const matrix = MatrixRotation3D(DegreesToRadians(60), DegreesToRadians(30), DegreesToRadians(45));
+                // Matrix should not be identity
+                expect(matrix).not.toEqual([
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+                // Should be a proper rotation matrix (orthogonal with determinant 1)
+                // Basic check: bottom row should be [0, 0, 0, 1]
+                expectMatrixToBeCloseTo([matrix[3]], [[0, 0, 0, 1]]);
+            });
+            test('should handle vector input', () => {
+                const eulerAngles = [Math.PI / 4, Math.PI / 6, Math.PI / 3];
+                const matrix = MatrixRotation3D(eulerAngles);
+                const expected = MatrixRotation3D(Math.PI / 4, Math.PI / 6, Math.PI / 3);
+                expectMatrixToBeCloseTo(matrix, expected);
+            });
+        });
+        describe('MatrixRotation3DEulerAngles', () => {
+            test('should convert degrees to radians and create rotation matrix', () => {
+                const matrix = MatrixRotation3DEulerAngles(60, 30, 45);
+                const expected = MatrixRotation3D(DegreesToRadians(60), DegreesToRadians(30), DegreesToRadians(45));
+                expectMatrixToBeCloseTo(matrix, expected);
+            });
+            test('should handle zero degrees', () => {
+                const matrix = MatrixRotation3DEulerAngles(0, 0, 0);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+        });
+    });
+    describe('Scaling Transformations', () => {
+        describe('Matrix_Transformation_Scale2D', () => {
+            test('should create identity scale for (1, 1)', () => {
+                const matrix = MatrixScale2D(1, 1);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0],
+                    [0, 1, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should create proper scale matrix', () => {
+                const matrix = MatrixScale2D(2, 3);
+                expectMatrixToBeCloseTo(matrix, [
+                    [2, 0, 0],
+                    [0, 3, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should handle negative scaling (flipping)', () => {
+                const matrix = MatrixScale2D(-1, 1);
+                expectMatrixToBeCloseTo(matrix, [
+                    [-1, 0, 0],
+                    [0, 1, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should handle zero scaling', () => {
+                const matrix = MatrixScale2D(0, 1);
+                expectMatrixToBeCloseTo(matrix, [
+                    [0, 0, 0],
+                    [0, 1, 0],
+                    [0, 0, 1],
+                ]);
+            });
+        });
+        describe('Matrix_Transformation_Scale3D', () => {
+            test('should create identity scale for (1, 1, 1)', () => {
+                const matrix = MatrixScale3D(1, 1, 1);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should create proper 3D scale matrix', () => {
+                const matrix = MatrixScale3D(2, 3, 4);
+                expectMatrixToBeCloseTo(matrix, [
+                    [2, 0, 0, 0],
+                    [0, 3, 0, 0],
+                    [0, 0, 4, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should handle negative scaling', () => {
+                const matrix = MatrixScale3D(-1, -1, -1);
+                expectMatrixToBeCloseTo(matrix, [
+                    [-1, 0, 0, 0],
+                    [0, -1, 0, 0],
+                    [0, 0, -1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+        });
+    });
+    describe('Scale Transformations', () => {
+        describe('MatrixScale2D', () => {
+            test('should create uniform scale matrix', () => {
+                const matrix = MatrixScale2D(2);
+                expectMatrixToBeCloseTo(matrix, [
+                    [2, 0, 0],
+                    [0, 2, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should create identity for scale 1', () => {
+                const matrix = MatrixScale2D(1);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0],
+                    [0, 1, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should create independent scale matrix', () => {
+                const matrix = MatrixScale2D(2, 3);
+                expectMatrixToBeCloseTo(matrix, [
+                    [2, 0, 0],
+                    [0, 3, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should handle vector input', () => {
+                const scaleVector = [2, 3];
+                const matrix = MatrixScale2D(scaleVector);
+                expectMatrixToBeCloseTo(matrix, [
+                    [2, 0, 0],
+                    [0, 3, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should handle negative scaling (flipping)', () => {
+                const matrix = MatrixScale2D(-1, 1);
+                expectMatrixToBeCloseTo(matrix, [
+                    [-1, 0, 0],
+                    [0, 1, 0],
+                    [0, 0, 1],
+                ]);
+            });
+        });
+        describe('MatrixScale3D', () => {
+            test('should create uniform scale matrix', () => {
+                const matrix = MatrixScale3D(2);
+                expectMatrixToBeCloseTo(matrix, [
+                    [2, 0, 0, 0],
+                    [0, 2, 0, 0],
+                    [0, 0, 2, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should create identity for scale 1', () => {
+                const matrix = MatrixScale3D(1);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should create independent scale matrix', () => {
+                const matrix = MatrixScale3D(2, 3, 4);
+                expectMatrixToBeCloseTo(matrix, [
+                    [2, 0, 0, 0],
+                    [0, 3, 0, 0],
+                    [0, 0, 4, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should handle vector input', () => {
+                const scaleVector = [2, 3, 4];
+                const matrix = MatrixScale3D(scaleVector);
+                expectMatrixToBeCloseTo(matrix, [
+                    [2, 0, 0, 0],
+                    [0, 3, 0, 0],
+                    [0, 0, 4, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+        });
+    });
+    describe('Translation Transformations', () => {
+        describe('MatrixTranslation2D', () => {
+            test('should create identity for zero translation', () => {
+                const matrix = MatrixTranslation2D(0, 0);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0],
+                    [0, 1, 0],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should create proper translation matrix', () => {
+                const matrix = MatrixTranslation2D(5, 7);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 5],
+                    [0, 1, 7],
+                    [0, 0, 1],
+                ]);
+            });
+            test('should handle negative translation', () => {
+                const matrix = MatrixTranslation2D(-3, -4);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, -3],
+                    [0, 1, -4],
+                    [0, 0, 1],
+                ]);
+            });
+        });
+        describe('MatrixTranslation3D', () => {
+            test('should create identity for zero translation', () => {
+                const matrix = MatrixTranslation3D(0, 0, 0);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should create proper 3D translation matrix', () => {
+                const matrix = MatrixTranslation3D(1, 2, 3);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 1],
+                    [0, 1, 0, 2],
+                    [0, 0, 1, 3],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should handle uniform translation', () => {
+                const matrix = MatrixTranslation3D(5);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 5],
+                    [0, 1, 0, 5],
+                    [0, 0, 1, 5],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should handle vector input', () => {
+                const translationVector = [1, 2, 3];
+                const matrix = MatrixTranslation3D(translationVector[0], translationVector[1], translationVector[2]);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, 1],
+                    [0, 1, 0, 2],
+                    [0, 0, 1, 3],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should handle negative translation', () => {
+                const matrix = MatrixTranslation3D(-5, -10, -15);
+                expectMatrixToBeCloseTo(matrix, [
+                    [1, 0, 0, -5],
+                    [0, 1, 0, -10],
+                    [0, 0, 1, -15],
+                    [0, 0, 0, 1],
+                ]);
+            });
+        });
+    });
+    describe('Vector Transformations', () => {
+        describe('MatrixTransform2D', () => {
+            test('should transform vector with identity matrix', () => {
+                const identity = MatrixIdentity(3);
+                const vector = [3, 4];
+                const result = MatrixTransform2D(vector, identity);
+                expect(result[0]).toBeCloseTo(3);
+                expect(result[1]).toBeCloseTo(4);
+            });
+            test('should transform vector with translation', () => {
+                const translation = MatrixTranslation2D(2, 3);
+                const vector = [1, 1];
+                const result = MatrixTransform2D(vector, translation);
+                expect(result[0]).toBeCloseTo(3);
+                expect(result[1]).toBeCloseTo(4);
+            });
+            test('should transform vector with rotation', () => {
+                const rotation = MatrixRotation2D(Math.PI / 2);
+                const vector = [1, 0];
+                const result = MatrixTransform2D(vector, rotation);
+                expect(result[0]).toBeCloseTo(0, 5);
+                expect(result[1]).toBeCloseTo(1, 5);
+            });
+            test('should transform vector with scaling', () => {
+                const scale = MatrixScale2D(2, 3);
+                const vector = [4, 5];
+                const result = MatrixTransform2D(vector, scale);
+                expect(result[0]).toBeCloseTo(8);
+                expect(result[1]).toBeCloseTo(15);
+            });
+            test('should throw for invalid matrix', () => {
+                const invalidMatrix = [[1, 0], [0, 1]]; // Wrong size
+                // @ts-expect-error Invalid matrix size should cause a type error: MatrixTransform2D expects a 3x3 matrix
+                expect(() => MatrixTransform2D([1, 1], invalidMatrix)).toThrow();
+            });
+            test('should throw for invalid vector', () => {
+                const identity = MatrixIdentity(3);
+                expect(() => MatrixTransform2D([1], identity)).toThrow();
+            });
+            test('should throw for degenerate transformation', () => {
+                const degenerate = [
+                    [1, 0, 0],
+                    [0, 1, 0],
+                    [0, 0, 0], // w = 0 causes division by zero
+                ];
+                expect(() => MatrixTransform2D([1, 1], degenerate)).toThrow('2D transformation w component near zero');
+            });
+        });
+        describe('MatrixTransform3D', () => {
+            test('should transform vector with identity matrix', () => {
+                const identity = MatrixIdentity(4);
+                const vector = [3, 4, 5];
+                const result = MatrixTransform3D(vector, identity);
+                expect(result[0]).toBeCloseTo(3);
+                expect(result[1]).toBeCloseTo(4);
+                expect(result[2]).toBeCloseTo(5);
+            });
+            test('should transform vector with translation', () => {
+                const translation = MatrixTranslation3D(1, 2, 3);
+                const vector = [4, 5, 6];
+                const result = MatrixTransform3D(vector, translation);
+                expect(result[0]).toBeCloseTo(5);
+                expect(result[1]).toBeCloseTo(7);
+                expect(result[2]).toBeCloseTo(9);
+            });
+            test('should transform vector with rotation', () => {
+                const rotation = MatrixRotation3DYaw(Math.PI / 2);
+                const vector = [1, 0, 0];
+                const result = MatrixTransform3D(vector, rotation);
+                expect(result[0]).toBeCloseTo(0, 5);
+                expect(result[1]).toBeCloseTo(1, 5);
+                expect(result[2]).toBeCloseTo(0, 5);
+            });
+            test('should transform vector with scaling', () => {
+                const scale = MatrixScale3D(2, 3, 4);
+                const vector = [1, 2, 3];
+                const result = MatrixTransform3D(vector, scale);
+                expect(result[0]).toBeCloseTo(2);
+                expect(result[1]).toBeCloseTo(6);
+                expect(result[2]).toBeCloseTo(12);
+            });
+            test('should throw for invalid matrix', () => {
+                const invalidMatrix = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]; // Wrong size
+                // @ts-expect-error Invalid matrix size should cause a type error: MatrixTransform3D expects a 4x4 matrix
+                expect(() => MatrixTransform3D([1, 1, 1], invalidMatrix)).toThrow();
+            });
+            test('should throw for invalid vector', () => {
+                const identity = MatrixIdentity(4);
+                expect(() => MatrixTransform3D([1, 1], identity)).toThrow();
+            });
+            test('should throw for degenerate transformation', () => {
+                const degenerate = [
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 0], // w = 0 causes division by zero
+                ];
+                expect(() => MatrixTransform3D([1, 1, 1], degenerate)).toThrow('3D transformation w component near zero');
+            });
+        });
+        describe('MatrixDirection3D', () => {
+            test('should transform direction with identity matrix', () => {
+                const identity = MatrixIdentity(3);
+                const direction = [1, 0, 0];
+                const result = MatrixDirection3D(direction, identity);
+                expect(result[0]).toBeCloseTo(1);
+                expect(result[1]).toBeCloseTo(0);
+                expect(result[2]).toBeCloseTo(0);
+            });
+            test('should transform direction with rotation', () => {
+                // Extract 3x3 rotation part from 4x4 matrix
+                const yaw4x4 = MatrixRotation3DYaw(Math.PI / 2);
+                const rotation3x3 = [
+                    [yaw4x4[0][0], yaw4x4[0][1], yaw4x4[0][2]],
+                    [yaw4x4[1][0], yaw4x4[1][1], yaw4x4[1][2]],
+                    [yaw4x4[2][0], yaw4x4[2][1], yaw4x4[2][2]],
+                ];
+                const direction = [1, 0, 0];
+                const result = MatrixDirection3D(direction, rotation3x3);
+                expect(result[0]).toBeCloseTo(0, 5);
+                expect(result[1]).toBeCloseTo(1, 5);
+                expect(result[2]).toBeCloseTo(0, 5);
+            });
+            test('should ignore translation (direction vectors should not be translated)', () => {
+                // Create a 3x3 matrix that would translate if it were 4x4
+                const transform = [
+                    [1, 0, 5], // Translation component in 3x3 context
+                    [0, 1, 10],
+                    [0, 0, 1],
+                ];
+                const direction = [1, 1, 0];
+                const result = MatrixDirection3D(direction, transform);
+                // Should apply transformation but not translation effects
+                expect(result[0]).toBeCloseTo(1);
+                expect(result[1]).toBeCloseTo(1);
+                expect(result[2]).toBeCloseTo(0);
+            });
+            test('should throw for invalid matrix', () => {
+                const invalidMatrix = [[1, 0], [0, 1]]; // Wrong size
+                // @ts-expect-error Invalid matrix size should cause a type error: MatrixDirection3D expects a 3x3 matrix
+                expect(() => MatrixDirection3D([1, 1, 1], invalidMatrix)).toThrow();
+            });
+            test('should throw for invalid direction', () => {
+                const identity = [
+                    [1, 0, 0],
+                    [0, 1, 0],
+                    [0, 0, 1],
+                ];
+                expect(() => MatrixDirection3D([1, 1], identity)).toThrow();
+            });
+        });
+    });
+    describe('View and Projection Matrices', () => {
+        describe('MatrixView', () => {
+            test('should create view matrix looking down negative Z', () => {
+                const eye = [0, 0, 0];
+                const target = [0, 0, -1];
+                const up = [0, 1, 0];
+                const viewMatrix = MatrixView(eye, target, up);
+                // Should be approximately identity since we're at origin looking down -Z
+                expectMatrixToBeCloseTo(viewMatrix, [
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+            });
+            test('should create view matrix with translation', () => {
+                const eye = [0, 0, 5];
+                const target = [0, 0, 0];
+                const up = [0, 1, 0];
+                const viewMatrix = MatrixView(eye, target, up);
+                // Should translate camera position
+                expect(viewMatrix[0][3]).toBeCloseTo(0);
+                expect(viewMatrix[1][3]).toBeCloseTo(0);
+                expect(viewMatrix[2][3]).toBeCloseTo(-5);
+                expect(viewMatrix[3][3]).toBeCloseTo(1);
+            });
+            test('should create view matrix with rotation', () => {
+                const eye = [1, 0, 0];
+                const target = [0, 0, 0];
+                const up = [0, 1, 0];
+                const viewMatrix = MatrixView(eye, target, up);
+                // Camera is to the right of origin looking towards it
+                // This should create a rotation
+                expect(viewMatrix).not.toEqual([
+                    [1, 0, 0, 0],
+                    [0, 1, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 0, 0, 1],
+                ]);
+                // Bottom row should always be [0, 0, 0, 1]
+                expectMatrixToBeCloseTo([viewMatrix[3]], [[0, 0, 0, 1]]);
+            });
+            test('should throw for invalid vectors', () => {
+                expect(() => MatrixView([1, 2], [0, 0, 0], [0, 1, 0])).toThrow();
+                expect(() => MatrixView([0, 0, 0], [1, 2], [0, 1, 0])).toThrow();
+                expect(() => MatrixView([0, 0, 0], [0, 0, 0], [1, 2])).toThrow();
+            });
+        });
+        describe('Matrix_Transformation_Perspective', () => {
+            test('should create perspective matrix with valid parameters', () => {
+                const fovY = Math.PI / 4; // 45 degrees
+                const aspect = 16 / 9;
+                const near = 0.1;
+                const far = 100;
+                const perspective = MatrixPerspective(fovY, aspect, near, far);
+                // Should have specific structure for perspective matrix
+                expect(perspective[0][0]).toBeGreaterThan(0); // X scaling
+                expect(perspective[1][1]).toBeGreaterThan(0); // Y scaling
+                expect(perspective[2][2]).toBeLessThan(0); // Z mapping (negative)
+                expect(perspective[2][3]).toBeLessThan(0); // Z translation (negative)
+                expect(perspective[3][2]).toBe(-1); // Perspective trigger
+                expect(perspective[3][3]).toBe(0); // Clear diagonal
+            });
+            test('should throw for invalid near plane', () => {
+                expect(() => MatrixPerspective(Math.PI / 4, 1, 0, 100)).toThrow('Near clipping plane must be greater than 0');
+                expect(() => MatrixPerspective(Math.PI / 4, 1, -1, 100)).toThrow('Near clipping plane must be greater than 0');
+            });
+            test('should throw for invalid far plane', () => {
+                expect(() => MatrixPerspective(Math.PI / 4, 1, 1, 0)).toThrow('Far clipping plane must be greater than 0');
+                expect(() => MatrixPerspective(Math.PI / 4, 1, 1, -1)).toThrow('Far clipping plane must be greater than 0');
+            });
+            test('should throw when near >= far', () => {
+                expect(() => MatrixPerspective(Math.PI / 4, 1, 100, 100)).toThrow('Near clipping plane must be less than far clipping plane');
+                expect(() => MatrixPerspective(Math.PI / 4, 1, 100, 50)).toThrow('Near clipping plane must be less than far clipping plane');
+            });
+            test('should throw for invalid aspect ratio', () => {
+                expect(() => MatrixPerspective(Math.PI / 4, 0, 0.1, 100)).toThrow('Aspect ratio must be greater than 0');
+                expect(() => MatrixPerspective(Math.PI / 4, -1, 0.1, 100)).toThrow('Aspect ratio must be greater than 0');
+            });
+        });
+        describe('MatrixOrthographic', () => {
+            test('should create orthographic matrix with valid parameters', () => {
+                const left = -10;
+                const right = 10;
+                const bottom = -5;
+                const top = 5;
+                const near = -100;
+                const far = 100;
+                const ortho = MatrixOrthographic(left, right, bottom, top, near, far);
+                // Should have specific structure for orthographic matrix
+                expect(ortho[0][0]).toBeCloseTo(2 / (right - left)); // X scaling
+                expect(ortho[1][1]).toBeCloseTo(2 / (top - bottom)); // Y scaling
+                expect(ortho[2][2]).toBeCloseTo(-2 / (far - near)); // Z scaling (negative)
+                expect(ortho[0][3]).toBeCloseTo(-(right + left) / (right - left)); // X translation
+                expect(ortho[1][3]).toBeCloseTo(-(top + bottom) / (top - bottom)); // Y translation
+                expect(ortho[2][3]).toBeCloseTo(-(far + near) / (far - near)); // Z translation
+                expect(ortho[3][3]).toBe(1); // Homogeneous coordinate
+            });
+            test('should throw for equal boundaries', () => {
+                expect(() => MatrixOrthographic(5, 5, -5, 5, -100, 100)).toThrow('Left and right bounds must not be equal');
+                expect(() => MatrixOrthographic(-5, 5, 3, 3, -100, 100)).toThrow('Bottom and top bounds must not be equal');
+                expect(() => MatrixOrthographic(-5, 5, -5, 5, 50, 50)).toThrow('Near and far clipping planes must not be equal');
+            });
+            test('should handle negative coordinate spaces', () => {
+                const ortho = MatrixOrthographic(-100, -50, -25, -10, 10, 20);
+                // Should still create valid matrix
+                expect(ortho[3][3]).toBe(1);
+                expect(ortho[0][0]).toBeCloseTo(2 / (-50 - -100));
+                expect(ortho[1][1]).toBeCloseTo(2 / (-10 - -25));
+                expect(ortho[2][2]).toBeCloseTo(-2 / (20 - 10));
+            });
+        });
+    });
+    describe('Integration Tests', () => {
+        test('should compose transformations correctly', () => {
+            // Create a composite transformation: translate, then rotate, then scale
+            const translation = MatrixTranslation2D(5, 5);
+            const rotation = MatrixRotation2D(Math.PI / 4); // 45 degrees
+            const scale = MatrixScale2D(2, 2);
+            // Apply transformations in sequence
+            const point = [1, 0];
+            // First translate
+            const translated = MatrixTransform2D(point, translation);
+            expect(translated[0]).toBeCloseTo(6);
+            expect(translated[1]).toBeCloseTo(5);
+            // Then rotate
+            const rotated = MatrixTransform2D(translated, rotation);
+            // Then scale
+            const final = MatrixTransform2D(rotated, scale);
+            // Final result should be properly transformed
+            expect(final).toBeDefined();
+            expect(Array.isArray(final)).toBe(true);
+            expect(final.length).toBe(2);
+        });
+        test('should maintain vector magnitude for rotation only', () => {
+            const vector = [3, 4]; // magnitude = 5
+            const rotation = MatrixRotation2D(Math.PI / 3); // 60 degrees
+            const rotated = MatrixTransform2D(vector, rotation);
+            const originalMagnitude = VectorMagnitude(vector);
+            const rotatedMagnitude = VectorMagnitude(rotated);
+            expect(rotatedMagnitude).toBeCloseTo(originalMagnitude, 5);
+        });
+        test('should transform 3D vectors correctly with combined rotations', () => {
+            const vector = [1, 0, 0];
+            // First rotate around Y (pitch), then around Z (yaw)
+            const pitch90 = MatrixRotation3DPitch(Math.PI / 2);
+            const yaw90 = MatrixRotation3DYaw(Math.PI / 2);
+            const afterPitch = MatrixTransform3D(vector, pitch90);
+            expect(afterPitch[0]).toBeCloseTo(0, 5);
+            expect(afterPitch[1]).toBeCloseTo(0, 5);
+            expect(afterPitch[2]).toBeCloseTo(-1, 5);
+            const afterYaw = MatrixTransform3D(afterPitch, yaw90);
+            expect(afterYaw[0]).toBeCloseTo(0, 5);
+            expect(afterYaw[1]).toBeCloseTo(0, 5);
+            expect(afterYaw[2]).toBeCloseTo(-1, 5);
+        });
+        test('should preserve direction vector properties', () => {
+            const direction = [1, 1, 1];
+            const rotation3x3 = [
+                [1, 0, 0],
+                [0, 0, -1],
+                [0, 1, 0],
+            ];
+            const rotatedDirection = MatrixDirection3D(direction, rotation3x3);
+            const originalMagnitude = VectorMagnitude(direction);
+            const rotatedMagnitude = VectorMagnitude(rotatedDirection);
+            // Direction transformations should preserve magnitude
+            expect(rotatedMagnitude).toBeCloseTo(originalMagnitude, 5);
+        });
+    });
+});
+//# sourceMappingURL=transformations.spec.js.map