glmaths 0.0.2 → 0.0.4

package/tests/mat2.test.ts

@@ -1,34 +1,34 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import glmaths, { Mat2, mat2, Vec2 } from '../dist/esm/glmaths'
+import glmaths, { mat2, Mat2, vec2, Vec2 } from '../dist/esm/glmaths'
 
 function closeTo(actual: number, expected: number, numDigits = 5) { const pass = Math.abs(actual - expected) < Math.pow(10, -numDigits) / 2; assert.ok(pass, `expected ${actual} to be close to ${expected}`) }
 
 describe('Mat2', () => {
   describe('constructor', () => {
     it('creates zero matrix by default', () => {
-      const m = new Mat2()
+      const m = mat2()
       assert.strictEqual(m[0], 0)
       assert.strictEqual(m[1], 0)
       assert.strictEqual(m[2], 0)
       assert.strictEqual(m[3], 0)
     })
     it('creates with given values', () => {
-      const m = new Mat2(1, 2, 3, 4)
+      const m = mat2(1, 2, 3, 4)
       assert.strictEqual(m[0], 1)
       assert.strictEqual(m[1], 2)
       assert.strictEqual(m[2], 3)
       assert.strictEqual(m[3], 4)
     })
     it('extends Float32Array with length 4', () => {
-      assert.ok(new Mat2() instanceof Float32Array)
-      assert.strictEqual(new Mat2().length, 4)
+      assert.ok(mat2() instanceof Float32Array)
+      assert.strictEqual(mat2().length, 4)
     })
   })
 
   describe('identity', () => {
     it('creates identity matrix', () => {
-      const m = Mat2.identity
+      const m = mat2.identity
       assert.strictEqual(m[0], 1)
       assert.strictEqual(m[1], 0)
       assert.strictEqual(m[2], 0)
@@ -38,7 +38,7 @@ describe('Mat2', () => {
 
   describe('clone', () => {
     it('creates independent copy', () => {
-      const a = new Mat2(1, 2, 3, 4)
+      const a = mat2(1, 2, 3, 4)
       const b = a.clone()
       assert.strictEqual(b[0], 1)
       b[0] = 99
@@ -48,7 +48,7 @@ describe('Mat2', () => {
 
   describe('transpose', () => {
     it('transposes in-place', () => {
-      const m = new Mat2(1, 2, 3, 4)
+      const m = mat2(1, 2, 3, 4)
       const r = m.transpose()
       assert.strictEqual(r[0], 1)
       assert.strictEqual(r[1], 3)
@@ -56,8 +56,8 @@ describe('Mat2', () => {
       assert.strictEqual(r[3], 4)
     })
     it('transposes to out', () => {
-      const m = new Mat2(1, 2, 3, 4)
-      const out = new Mat2()
+      const m = mat2(1, 2, 3, 4)
+      const out = mat2()
       m.transpose(out)
       assert.strictEqual(out[0], 1)
       assert.strictEqual(out[1], 3)
@@ -68,33 +68,33 @@ describe('Mat2', () => {
 
   describe('invert', () => {
     it('inverts a matrix', () => {
-      const m = Mat2.identity
+      const m = mat2.identity
       const inv = m.invert()
       assert.notStrictEqual(inv, null)
       assert.strictEqual(m[0], 1)
       assert.strictEqual(m[3], 1)
     })
     it('inverts correctly', () => {
-      const m = new Mat2(1, 2, 3, 4)
-      const out = new Mat2()
+      const m = mat2(1, 2, 3, 4)
+      const out = mat2()
       m.invert(out)
       // m * m^-1 = identity
-      const result = m.multiply(out!, new Mat2())
+      const result = m.multiply(out!, mat2())
       closeTo(result[0], 1)
       closeTo(result[1], 0)
       closeTo(result[2], 0)
       closeTo(result[3], 1)
     })
     it('returns null for singular matrix', () => {
-      const m = new Mat2(1, 2, 2, 4)
-      assert.strictEqual(m.invert(new Mat2()), null)
+      const m = mat2(1, 2, 2, 4)
+      assert.strictEqual(m.invert(mat2()), null)
     })
   })
 
   describe('adjoint', () => {
     it('calculates adjugate', () => {
-      const m = new Mat2(1, 2, 3, 4)
-      const out = new Mat2()
+      const m = mat2(1, 2, 3, 4)
+      const out = mat2()
       m.adjoint(out)
       assert.strictEqual(out[0], 4)
       assert.strictEqual(out[1], -2)
@@ -105,17 +105,17 @@ describe('Mat2', () => {
 
   describe('determinant', () => {
     it('calculates determinant', () => {
-      const m = new Mat2(1, 2, 3, 4)
+      const m = mat2(1, 2, 3, 4)
       assert.strictEqual(m.determinant(), -2)
     })
     it('identity determinant is 1', () => {
-      assert.strictEqual(Mat2.identity.determinant(), 1)
+      assert.strictEqual(mat2.identity.determinant(), 1)
     })
   })
 
   describe('rotate', () => {
     it('rotates identity by 90 degrees', () => {
-      const m = Mat2.identity
+      const m = mat2.identity
       const r = m.rotate(Math.PI / 2)
       closeTo(r[0], 0)
       closeTo(r[1], 1)
@@ -126,8 +126,8 @@ describe('Mat2', () => {
 
   describe('scale', () => {
     it('scales identity matrix', () => {
-      const m = Mat2.identity
-      const r = m.scale(new Vec2(2, 3))
+      const m = mat2.identity
+      const r = m.scale(vec2(2, 3))
       assert.strictEqual(r[0], 2)
       assert.strictEqual(r[1], 0)
       assert.strictEqual(r[2], 0)
@@ -137,7 +137,7 @@ describe('Mat2', () => {
 
   describe('static fromRotation', () => {
     it('creates rotation matrix', () => {
-      const m = Mat2.fromRotation(Math.PI / 2)
+      const m = mat2.fromRotation(Math.PI / 2)
       closeTo(m[0], 0)
       closeTo(m[1], 1)
       closeTo(m[2], -1)
@@ -147,7 +147,7 @@ describe('Mat2', () => {
 
   describe('static fromScaling', () => {
     it('creates scaling matrix', () => {
-      const m = Mat2.fromScaling(new Vec2(2, 3))
+      const m = mat2.fromScaling(vec2(2, 3))
       assert.strictEqual(m[0], 2)
       assert.strictEqual(m[1], 0)
       assert.strictEqual(m[2], 0)
@@ -157,9 +157,9 @@ describe('Mat2', () => {
 
   describe('multiply', () => {
     it('multiplies two matrices', () => {
-      const a = new Mat2(1, 2, 3, 4)
-      const b = new Mat2(5, 6, 7, 8)
-      const out = new Mat2()
+      const a = mat2(1, 2, 3, 4)
+      const b = mat2(5, 6, 7, 8)
+      const out = mat2()
       a.multiply(b, out)
       assert.strictEqual(out[0], 1 * 5 + 3 * 6)
       assert.strictEqual(out[1], 2 * 5 + 4 * 6)
@@ -167,9 +167,9 @@ describe('Mat2', () => {
       assert.strictEqual(out[3], 2 * 7 + 4 * 8)
     })
     it('identity * A = A', () => {
-      const a = new Mat2(1, 2, 3, 4)
-      const out = new Mat2()
-      Mat2.identity.multiply(a, out)
+      const a = mat2(1, 2, 3, 4)
+      const out = mat2()
+      mat2.identity.multiply(a, out)
       assert.strictEqual(out[0], 1)
       assert.strictEqual(out[1], 2)
       assert.strictEqual(out[2], 3)
@@ -179,9 +179,9 @@ describe('Mat2', () => {
 
   describe('plus / minus', () => {
     it('adds matrices', () => {
-      const a = new Mat2(1, 2, 3, 4)
-      const b = new Mat2(5, 6, 7, 8)
-      const out = new Mat2()
+      const a = mat2(1, 2, 3, 4)
+      const b = mat2(5, 6, 7, 8)
+      const out = mat2()
       a.plus(b, out)
       assert.strictEqual(out[0], 6)
       assert.strictEqual(out[1], 8)
@@ -189,9 +189,9 @@ describe('Mat2', () => {
       assert.strictEqual(out[3], 12)
     })
     it('subtracts matrices', () => {
-      const a = new Mat2(5, 6, 7, 8)
-      const b = new Mat2(1, 2, 3, 4)
-      const out = new Mat2()
+      const a = mat2(5, 6, 7, 8)
+      const b = mat2(1, 2, 3, 4)
+      const out = mat2()
       a.minus(b, out)
       assert.strictEqual(out[0], 4)
       assert.strictEqual(out[1], 4)
@@ -202,7 +202,7 @@ describe('Mat2', () => {
 
   describe('scaleScalar', () => {
     it('scales all elements', () => {
-      const m = new Mat2(1, 2, 3, 4)
+      const m = mat2(1, 2, 3, 4)
       const r = m.scaleScalar(2)
       assert.strictEqual(r[0], 2)
       assert.strictEqual(r[1], 4)
@@ -213,31 +213,31 @@ describe('Mat2', () => {
 
   describe('equals / exactEquals', () => {
     it('exactEquals', () => {
-      assert.strictEqual(new Mat2(1, 2, 3, 4).exactEquals(new Mat2(1, 2, 3, 4)), true)
-      assert.strictEqual(new Mat2(1, 2, 3, 4).exactEquals(new Mat2(1, 2, 3, 5)), false)
+      assert.strictEqual(mat2(1, 2, 3, 4).exactEquals(mat2(1, 2, 3, 4)), true)
+      assert.strictEqual(mat2(1, 2, 3, 4).exactEquals(mat2(1, 2, 3, 5)), false)
     })
     it('equals with epsilon', () => {
-      const a = new Mat2(1, 2, 3, 4)
-      const b = new Mat2(1 + glmaths.EPSILON * 0.1, 2, 3, 4)
+      const a = mat2(1, 2, 3, 4)
+      const b = mat2(1 + glmaths.EPSILON * 0.1, 2, 3, 4)
       assert.strictEqual(a.equals(b), true)
     })
   })
 
   describe('toString', () => {
     it('returns string representation', () => {
-      assert.strictEqual(new Mat2(1, 2, 3, 4).toString(), 'mat2x2(1, 2, 3, 4)')
+      assert.strictEqual(mat2(1, 2, 3, 4).toString(), 'mat2x2(1, 2, 3, 4)')
     })
   })
 
   describe('frob', () => {
     it('frobenius norm of identity', () => {
-      closeTo(Mat2.identity.frob(), Math.sqrt(2))
+      closeTo(mat2.identity.frob(), Math.sqrt(2))
     })
   })
 
   describe('LDU', () => {
     it('factors a matrix', () => {
-      const m = new Mat2(4, 3, 6, 3)
+      const m = mat2(4, 3, 6, 3)
       const [L, D, U] = m.LDU()
       assert.ok(L instanceof Mat2)
       assert.ok(D instanceof Mat2)
@@ -255,20 +255,20 @@ describe('Mat2', () => {
 
   describe('mat * vec operators', () => {
     it('Mat2 * Vec2 rotation', () => {
-      const m = Mat2.fromRotation(Math.PI / 3)
-      const v = new Vec2(3, 4)
-      const expected = v.transformMat2(m, new Vec2())
+      const m = mat2.fromRotation(Math.PI / 3)
+      const v = vec2(3, 4)
+      const expected = v.transformMat2(m, vec2())
       const r = m * v
       assert.ok(r instanceof Vec2)
       closeTo(r.x, expected.x)
       closeTo(r.y, expected.y)
     })
     it('Mat2 * Vec2 scale + rotation', () => {
-      const m = Mat2.fromScaling(new Vec2(2, 3))
-      const rot = Mat2.fromRotation(Math.PI / 5)
-      const combined = rot.multiply(m, new Mat2())
-      const v = new Vec2(7, -2)
-      const expected = v.transformMat2(combined, new Vec2())
+      const m = mat2.fromScaling(vec2(2, 3))
+      const rot = mat2.fromRotation(Math.PI / 5)
+      const combined = rot.multiply(m, mat2())
+      const v = vec2(7, -2)
+      const expected = v.transformMat2(combined, vec2())
       const r = combined * v
       closeTo(r.x, expected.x)
       closeTo(r.y, expected.y)

package/tests/mat2x3.test.ts

@@ -1,6 +1,6 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import glmaths, { Mat2x3, mat2x3, Vec2 } from '../dist/esm/glmaths'
+import glmaths, { Mat2x3, mat2x3, vec2, Vec2 } from '../dist/esm/glmaths'
 
 function closeTo(actual: number, expected: number, numDigits = 5) {
   const pass = Math.abs(actual - expected) < Math.pow(10, -numDigits) / 2
@@ -10,23 +10,23 @@ function closeTo(actual: number, expected: number, numDigits = 5) {
 describe('Mat2x3', () => {
   describe('constructor', () => {
     it('creates zero matrix by default', () => {
-      const m = new Mat2x3()
+      const m = mat2x3()
       for (let i = 0; i < 6; i++) assert.strictEqual(m[i], 0)
     })
     it('creates with given values', () => {
-      const m = new Mat2x3(1, 2, 3, 4, 5, 6)
+      const m = mat2x3(1, 2, 3, 4, 5, 6)
       assert.strictEqual(m[0], 1)
       assert.strictEqual(m[5], 6)
     })
     it('extends Float32Array with length 6', () => {
-      assert.ok(new Mat2x3() instanceof Float32Array)
-      assert.strictEqual(new Mat2x3().length, 6)
+      assert.ok(mat2x3() instanceof Float32Array)
+      assert.strictEqual(mat2x3().length, 6)
     })
   })
 
   describe('identity', () => {
     it('creates identity', () => {
-      const m = Mat2x3.identity
+      const m = mat2x3.identity
       assert.strictEqual(m[0], 1)
       assert.strictEqual(m[1], 0)
       assert.strictEqual(m[2], 0)
@@ -38,18 +38,18 @@ describe('Mat2x3', () => {
 
   describe('determinant', () => {
     it('identity determinant is 1', () => {
-      assert.strictEqual(Mat2x3.identity.determinant(), 1)
+      assert.strictEqual(mat2x3.identity.determinant(), 1)
     })
     it('calculates determinant', () => {
-      const m = new Mat2x3(1, 2, 3, 4, 5, 6)
+      const m = mat2x3(1, 2, 3, 4, 5, 6)
       assert.strictEqual(m.determinant(), 1 * 4 - 2 * 3)
     })
   })
 
   describe('invert', () => {
     it('inverts identity to identity', () => {
-      const m = Mat2x3.identity
-      const out = new Mat2x3()
+      const m = mat2x3.identity
+      const out = mat2x3()
       m.invert(out)
       assert.strictEqual(out[0], 1)
       assert.strictEqual(out[3], 1)
@@ -57,15 +57,15 @@ describe('Mat2x3', () => {
       assert.strictEqual(out[5], 0)
     })
     it('returns null for singular matrix', () => {
-      const m = new Mat2x3(1, 2, 2, 4, 0, 0)
-      assert.strictEqual(m.invert(new Mat2x3()), null)
+      const m = mat2x3(1, 2, 2, 4, 0, 0)
+      assert.strictEqual(m.invert(mat2x3()), null)
     })
     it('inverse * original = identity (for the 2x2 part)', () => {
-      const m = new Mat2x3(2, 1, 1, 3, 5, 7)
-      const inv = new Mat2x3()
+      const m = mat2x3(2, 1, 1, 3, 5, 7)
+      const inv = mat2x3()
       m.invert(inv)
-      const result = new Mat2x3()
-      Mat2x3.identity.multiply.call(m, inv!, result)
+      const result = mat2x3()
+      mat2x3.identity.multiply.call(m, inv!, result)
       closeTo(result[0], 1)
       closeTo(result[1], 0)
       closeTo(result[2], 0)
@@ -75,7 +75,7 @@ describe('Mat2x3', () => {
 
   describe('rotate', () => {
     it('rotates identity by PI/2', () => {
-      const m = Mat2x3.identity
+      const m = mat2x3.identity
       const r = m.rotate(Math.PI / 2)
       closeTo(r[0], 0)
       closeTo(r[1], 1)
@@ -86,8 +86,8 @@ describe('Mat2x3', () => {
 
   describe('scale', () => {
     it('scales identity', () => {
-      const m = Mat2x3.identity
-      const r = m.scale(new Vec2(2, 3))
+      const m = mat2x3.identity
+      const r = m.scale(vec2(2, 3))
       assert.strictEqual(r[0], 2)
       assert.strictEqual(r[3], 3)
     })
@@ -95,8 +95,8 @@ describe('Mat2x3', () => {
 
   describe('translate', () => {
     it('translates identity', () => {
-      const m = Mat2x3.identity
-      const r = m.translate(new Vec2(5, 10))
+      const m = mat2x3.identity
+      const r = m.translate(vec2(5, 10))
       assert.strictEqual(r[4], 5)
       assert.strictEqual(r[5], 10)
     })
@@ -114,7 +114,7 @@ describe('Mat2x3', () => {
 
   describe('static fromScaling', () => {
     it('creates scaling matrix', () => {
-      const m = Mat2x3.fromScaling(new Vec2(2, 3))
+      const m = Mat2x3.fromScaling(vec2(2, 3))
       assert.strictEqual(m[0], 2)
       assert.strictEqual(m[3], 3)
     })
@@ -122,7 +122,7 @@ describe('Mat2x3', () => {
 
   describe('static fromTranslation', () => {
     it('creates translation matrix', () => {
-      const m = Mat2x3.fromTranslation(new Vec2(5, 10))
+      const m = Mat2x3.fromTranslation(vec2(5, 10))
       assert.strictEqual(m[0], 1)
       assert.strictEqual(m[3], 1)
       assert.strictEqual(m[4], 5)
@@ -132,26 +132,26 @@ describe('Mat2x3', () => {
 
   describe('multiply', () => {
     it('identity * A = A', () => {
-      const a = new Mat2x3(1, 2, 3, 4, 5, 6)
-      const out = new Mat2x3()
-      Mat2x3.identity.multiply(a, out)
+      const a = mat2x3(1, 2, 3, 4, 5, 6)
+      const out = mat2x3()
+      mat2x3.identity.multiply(a, out)
       for (let i = 0; i < 6; i++) assert.strictEqual(out[i], a[i])
     })
   })
 
   describe('plus / minus', () => {
     it('adds', () => {
-      const a = new Mat2x3(1, 2, 3, 4, 5, 6)
-      const b = new Mat2x3(6, 5, 4, 3, 2, 1)
-      const out = new Mat2x3()
+      const a = mat2x3(1, 2, 3, 4, 5, 6)
+      const b = mat2x3(6, 5, 4, 3, 2, 1)
+      const out = mat2x3()
       a.plus(b, out)
       assert.strictEqual(out[0], 7)
       assert.strictEqual(out[5], 7)
     })
     it('subtracts', () => {
-      const a = new Mat2x3(6, 5, 4, 3, 2, 1)
-      const b = new Mat2x3(1, 2, 3, 4, 5, 6)
-      const out = new Mat2x3()
+      const a = mat2x3(6, 5, 4, 3, 2, 1)
+      const b = mat2x3(1, 2, 3, 4, 5, 6)
+      const out = mat2x3()
       a.minus(b, out)
       assert.strictEqual(out[0], 5)
       assert.strictEqual(out[5], -5)
@@ -160,27 +160,27 @@ describe('Mat2x3', () => {
 
   describe('equals / exactEquals', () => {
     it('exactEquals', () => {
-      const a = new Mat2x3(1, 2, 3, 4, 5, 6)
-      const b = new Mat2x3(1, 2, 3, 4, 5, 6)
+      const a = mat2x3(1, 2, 3, 4, 5, 6)
+      const b = mat2x3(1, 2, 3, 4, 5, 6)
       assert.strictEqual(a.exactEquals(b), true)
     })
     it('equals with epsilon', () => {
-      const a = new Mat2x3(1, 2, 3, 4, 5, 6)
-      const b = new Mat2x3(1 + glmaths.EPSILON * 0.1, 2, 3, 4, 5, 6)
+      const a = mat2x3(1, 2, 3, 4, 5, 6)
+      const b = mat2x3(1 + glmaths.EPSILON * 0.1, 2, 3, 4, 5, 6)
       assert.strictEqual(a.equals(b), true)
     })
   })
 
   describe('toString', () => {
     it('returns string', () => {
-      const m = new Mat2x3(1, 0, 0, 1, 0, 0)
+      const m = mat2x3(1, 0, 0, 1, 0, 0)
       assert.ok(m.toString().includes('mat2x3'))
     })
   })
 
   describe('frob', () => {
     it('frobenius norm of identity', () => {
-      closeTo(Mat2x3.identity.frob(), Math.sqrt(3))
+      closeTo(mat2x3.identity.frob(), Math.sqrt(3))
     })
   })
 
@@ -194,21 +194,21 @@ describe('Mat2x3', () => {
   describe('mat * vec operators', () => {
     it('Mat2x3 * Vec2 rotation + translation', () => {
       const m = Mat2x3.fromRotation(Math.PI / 3)
-      m.translate(new Vec2(10, 20))
-      const v = new Vec2(4, -1)
-      const expected = v.transformMat2x3(m, new Vec2())
+      m.translate(vec2(10, 20))
+      const v = vec2(4, -1)
+      const expected = v.transformMat2x3(m, vec2())
       const r = m * v
       assert.ok(r instanceof Vec2)
       closeTo(r.x, expected.x)
       closeTo(r.y, expected.y)
     })
     it('Mat2x3 * Vec2 scale + rotation + translation', () => {
-      const m = Mat2x3.identity
-      m.scale(new Vec2(2, 3))
+      const m = mat2x3.identity
+      m.scale(vec2(2, 3))
       m.rotate(Math.PI / 4)
-      m.translate(new Vec2(5, 10))
-      const v = new Vec2(3, 7)
-      const expected = v.transformMat2x3(m, new Vec2())
+      m.translate(vec2(5, 10))
+      const v = vec2(3, 7)
+      const expected = v.transformMat2x3(m, vec2())
       const r = m * v
       closeTo(r.x, expected.x)
       closeTo(r.y, expected.y)