glmaths 0.0.2 → 0.0.4

package/tests/mat3.test.ts

@@ -1,6 +1,6 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import glmaths, { Mat3, mat3, Mat2x3, Quat, Vec2, Vec3 } from '../dist/esm/glmaths'
+import glmaths, { Mat3, mat3, Mat2x3, quat, Quat, vec2, Vec2, vec3, Vec3 } from '../dist/esm/glmaths'
 
 function closeTo(actual: number, expected: number, numDigits = 5) {
   const pass = Math.abs(actual - expected) < Math.pow(10, -numDigits) / 2
@@ -10,22 +10,22 @@ function closeTo(actual: number, expected: number, numDigits = 5) {
 describe('Mat3', () => {
   describe('constructor', () => {
     it('creates zero matrix by default', () => {
-      const m = new Mat3()
+      const m = mat3()
       for (let i = 0; i < 9; i++) assert.strictEqual(m[i], 0)
     })
     it('creates with given values', () => {
-      const m = new Mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
+      const m = mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
       assert.strictEqual(m[0], 1)
       assert.strictEqual(m[8], 9)
     })
     it('extends Float32Array with length 9', () => {
-      assert.strictEqual(new Mat3().length, 9)
+      assert.strictEqual(mat3().length, 9)
     })
   })
 
   describe('identity', () => {
     it('creates identity', () => {
-      const m = Mat3.identity
+      const m = mat3.identity
       assert.strictEqual(m[0], 1)
       assert.strictEqual(m[4], 1)
       assert.strictEqual(m[8], 1)
@@ -36,7 +36,7 @@ describe('Mat3', () => {
 
   describe('clone', () => {
     it('clones independently', () => {
-      const a = new Mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
+      const a = mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
       const b = a.clone()
       b[0] = 99
       assert.strictEqual(a[0], 1)
@@ -45,7 +45,7 @@ describe('Mat3', () => {
 
   describe('transpose', () => {
     it('transposes in-place', () => {
-      const m = new Mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
+      const m = mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
       const r = m.transpose()
       assert.strictEqual(r[1], 4)
       assert.strictEqual(r[3], 2)
@@ -53,8 +53,8 @@ describe('Mat3', () => {
       assert.strictEqual(r[6], 3)
     })
     it('transposes to out', () => {
-      const m = new Mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
-      const out = new Mat3()
+      const m = mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
+      const out = mat3()
       m.transpose(out)
       assert.strictEqual(out[1], 4)
       assert.strictEqual(out[3], 2)
@@ -63,18 +63,18 @@ describe('Mat3', () => {
 
   describe('invert', () => {
     it('inverts identity to identity', () => {
-      const m = Mat3.identity
-      const out = new Mat3()
+      const m = mat3.identity
+      const out = mat3()
       m.invert(out)
       closeTo(out[0], 1)
       closeTo(out[4], 1)
       closeTo(out[8], 1)
     })
     it('m * m^-1 = identity', () => {
-      const m = new Mat3(1, 0, 0, 0, 2, 0, 0, 0, 3)
-      const inv = new Mat3()
+      const m = mat3(1, 0, 0, 0, 2, 0, 0, 0, 3)
+      const inv = mat3()
       m.invert(inv)
-      const result = new Mat3()
+      const result = mat3()
       m.multiply(inv!, result)
       closeTo(result[0], 1)
       closeTo(result[4], 1)
@@ -82,15 +82,15 @@ describe('Mat3', () => {
       closeTo(result[1], 0)
     })
     it('returns null for singular matrix', () => {
-      const m = new Mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
-      assert.strictEqual(m.invert(new Mat3()), null)
+      const m = mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
+      assert.strictEqual(m.invert(mat3()), null)
     })
   })
 
   describe('adjoint', () => {
     it('adjoint of identity is identity', () => {
-      const out = new Mat3()
-      Mat3.identity.adjoint(out)
+      const out = mat3()
+      mat3.identity.adjoint(out)
       assert.strictEqual(out[0], 1)
       assert.strictEqual(out[4], 1)
       assert.strictEqual(out[8], 1)
@@ -99,31 +99,31 @@ describe('Mat3', () => {
 
   describe('determinant', () => {
     it('identity determinant is 1', () => {
-      assert.strictEqual(Mat3.identity.determinant(), 1)
+      assert.strictEqual(mat3.identity.determinant(), 1)
     })
     it('diagonal matrix determinant is product of diagonal', () => {
-      const m = new Mat3(2, 0, 0, 0, 3, 0, 0, 0, 4)
+      const m = mat3(2, 0, 0, 0, 3, 0, 0, 0, 4)
       assert.strictEqual(m.determinant(), 24)
     })
     it('singular matrix determinant is 0', () => {
-      const m = new Mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
+      const m = mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
       closeTo(m.determinant(), 0)
     })
   })
 
   describe('multiply', () => {
     it('identity * A = A', () => {
-      const a = new Mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
-      const out = new Mat3()
-      Mat3.identity.multiply(a, out)
+      const a = mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)
+      const out = mat3()
+      mat3.identity.multiply(a, out)
       for (let i = 0; i < 9; i++) closeTo(out[i], a[i])
     })
   })
 
   describe('translate', () => {
     it('translates identity', () => {
-      const m = Mat3.identity
-      const r = m.translate(new Vec2(5, 10))
+      const m = mat3.identity
+      const r = m.translate(vec2(5, 10))
       assert.strictEqual(r[6], 5)
       assert.strictEqual(r[7], 10)
       assert.strictEqual(r[8], 1)
@@ -132,7 +132,7 @@ describe('Mat3', () => {
 
   describe('rotate', () => {
     it('rotates identity by PI/2', () => {
-      const m = Mat3.identity
+      const m = mat3.identity
       const r = m.rotate(Math.PI / 2)
       closeTo(r[0], 0)
       closeTo(r[1], 1)
@@ -143,8 +143,8 @@ describe('Mat3', () => {
 
   describe('scale', () => {
     it('scales identity', () => {
-      const m = Mat3.identity
-      const r = m.scale(new Vec2(2, 3))
+      const m = mat3.identity
+      const r = m.scale(vec2(2, 3))
       assert.strictEqual(r[0], 2)
       assert.strictEqual(r[4], 3)
       assert.strictEqual(r[8], 1)
@@ -153,7 +153,7 @@ describe('Mat3', () => {
 
   describe('static fromTranslation', () => {
     it('creates translation matrix', () => {
-      const m = Mat3.fromTranslation(new Vec2(5, 10))
+      const m = mat3.fromTranslation(vec2(5, 10))
       assert.strictEqual(m[0], 1)
       assert.strictEqual(m[4], 1)
       assert.strictEqual(m[6], 5)
@@ -164,7 +164,7 @@ describe('Mat3', () => {
 
   describe('static fromRotation', () => {
     it('creates rotation matrix', () => {
-      const m = Mat3.fromRotation(Math.PI / 2)
+      const m = mat3.fromRotation(Math.PI / 2)
       closeTo(m[0], 0)
       closeTo(m[1], 1)
       closeTo(m[3], -1)
@@ -174,7 +174,7 @@ describe('Mat3', () => {
 
   describe('static fromScaling', () => {
     it('creates scaling matrix', () => {
-      const m = Mat3.fromScaling(new Vec2(2, 3))
+      const m = mat3.fromScaling(vec2(2, 3))
       assert.strictEqual(m[0], 2)
       assert.strictEqual(m[4], 3)
       assert.strictEqual(m[8], 1)
@@ -184,7 +184,7 @@ describe('Mat3', () => {
   describe('static fromMat2x3', () => {
     it('converts from Mat2x3', () => {
       const a = new Mat2x3(1, 0, 0, 1, 5, 10)
-      const m = Mat3.fromMat2x3(a)
+      const m = mat3.fromMat2x3(a)
       assert.strictEqual(m[0], 1)
       assert.strictEqual(m[4], 1)
       assert.strictEqual(m[6], 5)
@@ -195,8 +195,8 @@ describe('Mat3', () => {
 
   describe('static fromQuat', () => {
     it('identity quaternion gives identity matrix', () => {
-      const q = Quat.identity
-      const m = Mat3.fromQuat(q)
+      const q = quat.identity
+      const m = mat3.fromQuat(q)
       closeTo(m[0], 1)
       closeTo(m[4], 1)
       closeTo(m[8], 1)
@@ -206,7 +206,7 @@ describe('Mat3', () => {
 
   describe('static projection', () => {
     it('creates 2D projection', () => {
-      const m = Mat3.projection(100, 200)
+      const m = mat3.projection(100, 200)
       closeTo(m[0], 2 / 100)
       closeTo(m[4], -2 / 200)
     })
@@ -214,17 +214,17 @@ describe('Mat3', () => {
 
   describe('plus / minus', () => {
     it('adds', () => {
-      const a = Mat3.identity
-      const b = Mat3.identity
-      const out = new Mat3()
+      const a = mat3.identity
+      const b = mat3.identity
+      const out = mat3()
       a.plus(b, out)
       assert.strictEqual(out[0], 2)
       assert.strictEqual(out[4], 2)
     })
     it('subtracts', () => {
-      const a = Mat3.identity
-      const b = Mat3.identity
-      const out = new Mat3()
+      const a = mat3.identity
+      const b = mat3.identity
+      const out = mat3()
       a.minus(b, out)
       assert.strictEqual(out[0], 0)
     })
@@ -232,7 +232,7 @@ describe('Mat3', () => {
 
   describe('scaleScalar', () => {
     it('scales all elements', () => {
-      const m = Mat3.identity
+      const m = mat3.identity
       const r = m.scaleScalar(3)
       assert.strictEqual(r[0], 3)
       assert.strictEqual(r[4], 3)
@@ -242,17 +242,17 @@ describe('Mat3', () => {
 
   describe('frob', () => {
     it('frobenius norm of identity', () => {
-      closeTo(Mat3.identity.frob(), Math.sqrt(3))
+      closeTo(mat3.identity.frob(), Math.sqrt(3))
     })
   })
 
   describe('equals / exactEquals', () => {
     it('exactEquals', () => {
-      assert.strictEqual(Mat3.identity.exactEquals(Mat3.identity), true)
+      assert.strictEqual(mat3.identity.exactEquals(mat3.identity), true)
     })
     it('equals with epsilon', () => {
-      const a = Mat3.identity
-      const b = Mat3.identity
+      const a = mat3.identity
+      const b = mat3.identity
       b[0] = 1 + glmaths.EPSILON * 0.1
       assert.strictEqual(a.equals(b), true)
     })
@@ -260,7 +260,7 @@ describe('Mat3', () => {
 
   describe('toString', () => {
     it('returns string', () => {
-      assert.ok(Mat3.identity.toString().includes('mat3'))
+      assert.ok(mat3.identity.toString().includes('mat3'))
     })
   })
 
@@ -273,10 +273,10 @@ describe('Mat3', () => {
 
   describe('mat * vec operators', () => {
     it('Mat3 * Vec3 from quat rotation', () => {
-      const q = Quat.fromAxisAngle(new Vec3(1, 1, 0).normalize(), Math.PI / 3)
-      const m = Mat3.fromQuat(q)
-      const v = new Vec3(2, 3, 4)
-      const expected = v.transformMat3(m, new Vec3())
+      const q = quat.fromAxisAngle(vec3(1, 1, 0).normalize(), Math.PI / 3)
+      const m = mat3.fromQuat(q)
+      const v = vec3(2, 3, 4)
+      const expected = v.transformMat3(m, vec3())
       const r = m * v
       assert.ok(r instanceof Vec3)
       closeTo(r.x, expected.x)
@@ -284,19 +284,19 @@ describe('Mat3', () => {
       closeTo(r.z, expected.z)
     })
     it('Mat3 * Vec3 scale + rotation', () => {
-      const m = Mat3.fromRotation(Math.PI / 3)
-      m.scale(new Vec2(2, 3))
-      const v = new Vec3(1, 1, 1)
-      const expected = v.transformMat3(m, new Vec3())
+      const m = mat3.fromRotation(Math.PI / 3)
+      m.scale(vec2(2, 3))
+      const v = vec3(1, 1, 1)
+      const expected = v.transformMat3(m, vec3())
       const r = m * v
       closeTo(r.x, expected.x)
       closeTo(r.y, expected.y)
       closeTo(r.z, expected.z)
     })
     it('Mat3 * Vec2 rotation via mat3', () => {
-      const m = Mat3.fromRotation(Math.PI / 4)
-      const v = new Vec2(5, 7)
-      const expected = v.transformMat3(m, new Vec2())
+      const m = mat3.fromRotation(Math.PI / 4)
+      const v = vec2(5, 7)
+      const expected = v.transformMat3(m, vec2())
       const r = m * v
       assert.ok(r instanceof Vec2)
       closeTo(r.x, expected.x)