glmaths 0.0.1

package/tests/quat.test.ts

@@ -0,0 +1,418 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { Quat, Vec3, vec3, Vec4, Mat3 } 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('Quat', () => {
+  describe('constructor', () => {
+    it('defaults to identity (0,0,0,1)', () => {
+      const q = new Quat()
+      assert.strictEqual(q[0], 0)
+      assert.strictEqual(q[1], 0)
+      assert.strictEqual(q[2], 0)
+      assert.strictEqual(q[3], 1)
+    })
+    it('creates with given values', () => {
+      const q = new Quat(1, 2, 3, 4)
+      assert.strictEqual(q[0], 1)
+      assert.strictEqual(q[1], 2)
+      assert.strictEqual(q[2], 3)
+      assert.strictEqual(q[3], 4)
+    })
+  })
+
+  describe('identity', () => {
+    it('creates identity quaternion', () => {
+      const q = Quat.identity
+      assert.strictEqual(q[0], 0)
+      assert.strictEqual(q[1], 0)
+      assert.strictEqual(q[2], 0)
+      assert.strictEqual(q[3], 1)
+    })
+  })
+
+  describe('multiply (Hamilton product)', () => {
+    it('identity * identity = identity', () => {
+      const a = Quat.identity
+      const b = Quat.identity
+      const out = new Quat()
+      a.multiply(b, out)
+      closeTo(out[0], 0)
+      closeTo(out[1], 0)
+      closeTo(out[2], 0)
+      closeTo(out[3], 1)
+    })
+    it('identity * q = q', () => {
+      const q = new Quat(1, 2, 3, 4)
+      const out = new Quat()
+      Quat.identity.multiply(q, out)
+      closeTo(out[0], 1)
+      closeTo(out[1], 2)
+      closeTo(out[2], 3)
+      closeTo(out[3], 4)
+    })
+    it('q * conjugate(q) = unit quaternion', () => {
+      const q = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 4)
+      const conj = new Quat()
+      Quat.conjugate(q, conj)
+      const out = new Quat()
+      q.multiply(conj, out)
+      closeTo(out[0], 0)
+      closeTo(out[1], 0)
+      closeTo(out[2], 0)
+      closeTo(out[3], 1, 4)
+    })
+    it('scalar multiply scales all components', () => {
+      const q = new Quat(1, 2, 3, 4)
+      const out = new Quat()
+      q.multiply(2, out)
+      closeTo(out[0], 2)
+      closeTo(out[1], 4)
+      closeTo(out[2], 6)
+      closeTo(out[3], 8)
+    })
+    it('mult/mul/times are aliases for multiply', () => {
+      const q = Quat.identity
+      assert.strictEqual(q.mult, q.multiply)
+      assert.strictEqual(q.mul, q.multiply)
+      assert.strictEqual(q.times, q.multiply)
+    })
+    it('composing two 90-degree rotations around Y gives 180-degree', () => {
+      const q90 = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 2)
+      let q = Quat.identity
+      q = q.rotateY(Math.PI / 2)
+      q = q.rotateY(Math.PI / 2)
+      const q180 = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI)
+      const dot = q[0] * q180[0] + q[1] * q180[1] + q[2] * q180[2] + q[3] * q180[3]
+      closeTo(Math.abs(dot), 1, 4)
+    })
+    it('composing X then Y rotation produces correct result', () => {
+      const q = Quat.identity
+      q.rotateX(Math.PI / 2)
+      q.rotateY(Math.PI / 2)
+      const len = Math.sqrt(q[0] ** 2 + q[1] ** 2 + q[2] ** 2 + q[3] ** 2)
+      closeTo(len, 1, 4)
+    })
+  })
+
+  describe('fromAxisAngle', () => {
+    it('creates quaternion from axis and angle', () => {
+      const q = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 2)
+      closeTo(q[0], 0)
+      closeTo(q[1], Math.sin(Math.PI / 4))
+      closeTo(q[2], 0)
+      closeTo(q[3], Math.cos(Math.PI / 4))
+    })
+    it('zero angle gives identity', () => {
+      const q = Quat.fromAxisAngle(new Vec3(1, 0, 0), 0)
+      closeTo(q[0], 0)
+      closeTo(q[3], 1)
+    })
+  })
+
+  describe('setAxisAngle', () => {
+    it('sets quaternion to axis/angle', () => {
+      const q = new Quat()
+      const r = q.setAxisAngle(new Vec3(0, 0, 1), Math.PI / 2)
+      closeTo(r[2], Math.sin(Math.PI / 4))
+      closeTo(r[3], Math.cos(Math.PI / 4))
+    })
+  })
+
+  describe('getAxisAngle', () => {
+    it('recovers axis from fromAxisAngle', () => {
+      const axis = new Vec3(0, 1, 0)
+      const q = Quat.fromAxisAngle(axis, Math.PI / 3)
+      const recovered = vec3()
+      q.getAxisAngle(recovered)
+      closeTo(recovered[0], 0)
+      closeTo(recovered[1], 1)
+      closeTo(recovered[2], 0)
+    })
+  })
+
+  describe('angle', () => {
+    it('angle between identical quaternions is 0', () => {
+      const q = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 4)
+      closeTo(Quat.angle(q, q), 0, 2)
+    })
+  })
+
+  describe('rotateX / rotateY / rotateZ', () => {
+    it('rotateX from identity', () => {
+      const q = Quat.identity
+      const r = q.rotateX(Math.PI / 2)
+      closeTo(r[0], Math.sin(Math.PI / 4))
+      closeTo(r[3], Math.cos(Math.PI / 4))
+    })
+    it('rotateY from identity', () => {
+      const q = Quat.identity
+      const r = q.rotateY(Math.PI / 2)
+      closeTo(r[1], Math.sin(Math.PI / 4))
+      closeTo(r[3], Math.cos(Math.PI / 4))
+    })
+    it('rotateZ from identity', () => {
+      const q = Quat.identity
+      const r = q.rotateZ(Math.PI / 2)
+      closeTo(r[2], Math.sin(Math.PI / 4))
+      closeTo(r[3], Math.cos(Math.PI / 4))
+    })
+  })
+
+  describe('calculateW', () => {
+    it('recovers W for unit quaternion', () => {
+      const q = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 4)
+      const w = q.calculateW()
+      closeTo(w, q[3], 4)
+    })
+  })
+
+  describe('exp / ln', () => {
+    it('ln(exp(q)) ~= q for small q', () => {
+      const q = new Quat(0.1, 0.2, 0.3, 0)
+      const out = new Quat()
+      Quat.exp(q, out)
+      const back = new Quat()
+      Quat.ln(out, back)
+      closeTo(back[0], q[0], 4)
+      closeTo(back[1], q[1], 4)
+      closeTo(back[2], q[2], 4)
+    })
+    it('instance exp/ln roundtrip', () => {
+      const q = new Quat(0.1, 0.2, 0.3, 0)
+      const e = new Quat()
+      q.exp(e)
+      const back = new Quat()
+      e.ln(back)
+      closeTo(back[0], q[0], 4)
+    })
+  })
+
+  describe('pow', () => {
+    it('q^1 ~= q for unit quaternion', () => {
+      const q = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 4)
+      const original = new Quat(q[0], q[1], q[2], q[3])
+      q.pow(1)
+      closeTo(q[0], original[0], 3)
+      closeTo(q[1], original[1], 3)
+      closeTo(q[2], original[2], 3)
+      closeTo(q[3], original[3], 3)
+    })
+  })
+
+  describe('slerp', () => {
+    it('slerp(a, b, 0) = a', () => {
+      const a = Quat.fromAxisAngle(new Vec3(0, 1, 0), 0)
+      const b = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 2)
+      const out = Quat.slerp(a, b, 0)
+      closeTo(out[0], a[0])
+      closeTo(out[1], a[1])
+      closeTo(out[2], a[2])
+      closeTo(out[3], a[3])
+    })
+    it('slerp(a, b, 1) = b', () => {
+      const a = Quat.fromAxisAngle(new Vec3(0, 1, 0), 0)
+      const b = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 2)
+      const out = Quat.slerp(a, b, 1)
+      closeTo(out[0], b[0])
+      closeTo(out[1], b[1])
+      closeTo(out[2], b[2])
+      closeTo(out[3], b[3])
+    })
+    it('slerp(a, a, t) = a', () => {
+      const a = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 4)
+      const out = Quat.slerp(a, a, 0.5)
+      closeTo(out[0], a[0])
+      closeTo(out[1], a[1])
+      closeTo(out[2], a[2])
+      closeTo(out[3], a[3])
+    })
+    it('instance slerp', () => {
+      const a = Quat.fromAxisAngle(new Vec3(0, 1, 0), 0)
+      const b = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 2)
+      const out = new Quat()
+      a.slerp(b, 0.5, out)
+      const halfQ = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 4)
+      closeTo(out[1], halfQ[1], 4)
+      closeTo(out[3], halfQ[3], 4)
+    })
+  })
+
+  describe('invert', () => {
+    it('static invert gives conjugate for unit quaternion', () => {
+      const q = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 4)
+      const inv = Quat.invert(q)
+      closeTo(inv[0], -q[0])
+      closeTo(inv[1], -q[1])
+      closeTo(inv[2], -q[2])
+      closeTo(inv[3], q[3])
+    })
+    it('instance invert', () => {
+      const q = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 4)
+      const out = new Quat()
+      q.invert(out)
+      closeTo(out[1], -q[1])
+    })
+  })
+
+  describe('conjugate', () => {
+    it('static conjugate negates xyz', () => {
+      const q = new Quat(1, 2, 3, 4)
+      const out = Quat.conjugate(q)
+      assert.strictEqual(out[0], -1)
+      assert.strictEqual(out[1], -2)
+      assert.strictEqual(out[2], -3)
+      assert.strictEqual(out[3], 4)
+    })
+    it('instance conjugate', () => {
+      const q = new Quat(1, 2, 3, 4)
+      const r = q.conjugate()
+      assert.strictEqual(r[0], -1)
+      assert.strictEqual(r[3], 4)
+    })
+  })
+
+  describe('fromMat3', () => {
+    it('identity matrix gives identity quaternion', () => {
+      const q = Quat.fromMat3(Mat3.identity)
+      closeTo(q[0], 0)
+      closeTo(q[1], 0)
+      closeTo(q[2], 0)
+      closeTo(q[3], 1)
+    })
+    it('roundtrips with Mat3.fromQuat', () => {
+      const original = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 3)
+      const mat = Mat3.fromQuat(original)
+      const recovered = Quat.fromMat3(mat)
+      const dot = original[0] * recovered[0] + original[1] * recovered[1] +
+                  original[2] * recovered[2] + original[3] * recovered[3]
+      closeTo(Math.abs(dot), 1, 4)
+    })
+  })
+
+  describe('fromEuler', () => {
+    it('zero angles give identity', () => {
+      const q = Quat.fromEuler(0, 0, 0)
+      closeTo(q[0], 0)
+      closeTo(q[1], 0)
+      closeTo(q[2], 0)
+      closeTo(q[3], 1)
+    })
+    it('90 degree Y rotation', () => {
+      const q = Quat.fromEuler(0, 90, 0, 'zyx')
+      const expected = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 2)
+      const dot = q[0] * expected[0] + q[1] * expected[1] + q[2] * expected[2] + q[3] * expected[3]
+      closeTo(Math.abs(dot), 1, 4)
+    })
+    it('throws for unknown order', () => {
+      assert.throws(() => Quat.fromEuler(0, 0, 0, 'abc'), { message: /Unknown angle order/ })
+    })
+    it('supports all valid orders', () => {
+      for (const order of ['xyz', 'xzy', 'yxz', 'yzx', 'zxy', 'zyx']) {
+        const q = Quat.fromEuler(30, 45, 60, order)
+        assert.ok(q instanceof Quat)
+        const len = Math.sqrt(q[0] ** 2 + q[1] ** 2 + q[2] ** 2 + q[3] ** 2)
+        closeTo(len, 1, 4)
+      }
+    })
+  })
+
+  describe('toString', () => {
+    it('returns string representation', () => {
+      const q = new Quat(1, 2, 3, 4)
+      assert.strictEqual(q.toString(), 'quat(1, 2, 3, 4)')
+    })
+  })
+
+  describe('rotationTo', () => {
+    it('rotation from X to Y axis', () => {
+      const q = Quat.rotationTo(new Vec3(1, 0, 0), new Vec3(0, 1, 0))
+      const m = Mat3.fromQuat(q)
+      const result = new Vec3(
+        m[0] * 1 + m[3] * 0 + m[6] * 0,
+        m[1] * 1 + m[4] * 0 + m[7] * 0,
+        m[2] * 1 + m[5] * 0 + m[8] * 0
+      )
+      closeTo(result[0], 0)
+      closeTo(result[1], 1)
+      closeTo(result[2], 0)
+    })
+    it('rotation from same vector returns identity', () => {
+      const q = Quat.rotationTo(new Vec3(1, 0, 0), new Vec3(1, 0, 0))
+      closeTo(q[0], 0)
+      closeTo(q[1], 0)
+      closeTo(q[2], 0)
+      closeTo(q[3], 1)
+    })
+    it('rotation from opposite vectors (180 degrees)', () => {
+      const q = Quat.rotationTo(new Vec3(1, 0, 0), new Vec3(-1, 0, 0))
+      const len = Math.sqrt(q[0] ** 2 + q[1] ** 2 + q[2] ** 2 + q[3] ** 2)
+      closeTo(len, 1, 4)
+    })
+  })
+
+  describe('random', () => {
+    it('produces unit quaternion', () => {
+      const q = Quat.random()
+      const len = Math.sqrt(q[0] ** 2 + q[1] ** 2 + q[2] ** 2 + q[3] ** 2)
+      closeTo(len, 1, 4)
+    })
+  })
+
+  describe('sqlerp', () => {
+    it('returns valid quaternion', () => {
+      const a = Quat.identity
+      const b = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 4)
+      const c = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 2)
+      const d = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI * 3 / 4)
+      const out = Quat.sqlerp(a, b, c, d, 0.5)
+      assert.ok(out instanceof Quat)
+    })
+  })
+
+  describe('euler angles', () => {
+    it('pitch/yaw/roll from identity is zero', () => {
+      const q = Quat.identity
+      closeTo(q.pitch(), 0)
+      closeTo(q.yaw(), 0)
+      closeTo(q.roll(), 0)
+    })
+    it('eulerAngles returns Vec3', () => {
+      const q = Quat.fromAxisAngle(new Vec3(1, 0, 0), Math.PI / 4)
+      const e = q.eulerAngles()
+      assert.ok(e instanceof Vec3)
+      closeTo(e[0], Math.PI / 4)
+    })
+  })
+
+  describe('toMat3 / toMat4', () => {
+    it('identity quat gives identity mat3', () => {
+      const m = Quat.identity.toMat3()
+      closeTo(m[0], 1)
+      closeTo(m[4], 1)
+      closeTo(m[8], 1)
+      closeTo(m[1], 0)
+    })
+    it('identity quat gives identity mat4', () => {
+      const m = Quat.identity.toMat4()
+      closeTo(m[0], 1)
+      closeTo(m[5], 1)
+      closeTo(m[10], 1)
+      closeTo(m[15], 1)
+      closeTo(m[1], 0)
+    })
+  })
+
+  describe('quatLookAt', () => {
+    it('looking down -Z gives identity-like quat', () => {
+      const q = Quat.quatLookAt(new Vec3(0, 0, -1), new Vec3(0, 1, 0))
+      const v = new Vec3(0, 0, -1)
+      v.transformQuat(q)
+      closeTo(v[2], -1, 1)
+    })
+  })
+})

package/tests/quat2.test.ts

@@ -0,0 +1,222 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { Quat2, Quat, Vec3, Mat4 } 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('Quat2', () => {
+  describe('constructor', () => {
+    it('defaults to identity (0,0,0,1, 0,0,0,0)', () => {
+      const dq = new Quat2()
+      assert.strictEqual(dq[0], 0)
+      assert.strictEqual(dq[1], 0)
+      assert.strictEqual(dq[2], 0)
+      assert.strictEqual(dq[3], 1)
+      assert.strictEqual(dq[4], 0)
+      assert.strictEqual(dq[5], 0)
+      assert.strictEqual(dq[6], 0)
+      assert.strictEqual(dq[7], 0)
+    })
+    it('extends Float32Array with length 8', () => {
+      const dq = new Quat2()
+      assert.ok(dq instanceof Float32Array)
+      assert.strictEqual(dq.length, 8)
+    })
+  })
+
+  describe('identity', () => {
+    it('creates identity dual quaternion', () => {
+      const dq = Quat2.identity
+      assert.strictEqual(dq[3], 1)
+      assert.strictEqual(dq[0], 0)
+      assert.strictEqual(dq[7], 0)
+    })
+  })
+
+  describe('fromRotationTranslation', () => {
+    it('creates from identity rotation and translation', () => {
+      const q = Quat.identity
+      const t = new Vec3(2, 4, 6)
+      const dq = Quat2.fromRotationTranslation(q, t)
+      const out = dq.getTranslation()
+      closeTo(out[0], 2)
+      closeTo(out[1], 4)
+      closeTo(out[2], 6)
+    })
+  })
+
+  describe('fromTranslation', () => {
+    it('creates from translation only', () => {
+      const dq = Quat2.fromTranslation(new Vec3(1, 2, 3))
+      const t = dq.getTranslation()
+      closeTo(t[0], 1)
+      closeTo(t[1], 2)
+      closeTo(t[2], 3)
+    })
+  })
+
+  describe('fromRotation', () => {
+    it('creates from rotation only', () => {
+      const q = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 2)
+      const dq = Quat2.fromRotation(q)
+      closeTo(dq[0], q[0])
+      closeTo(dq[1], q[1])
+      closeTo(dq[2], q[2])
+      closeTo(dq[3], q[3])
+      assert.strictEqual(dq[4], 0)
+      assert.strictEqual(dq[5], 0)
+      assert.strictEqual(dq[6], 0)
+      assert.strictEqual(dq[7], 0)
+    })
+  })
+
+  describe('fromMat4', () => {
+    it('round-trips through Mat4', () => {
+      const q = Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 4)
+      const t = new Vec3(1, 2, 3)
+      const m = Mat4.fromRotationTranslation(q, t)
+      const dq = Quat2.fromMat4(m)
+      const tOut = dq.getTranslation()
+      closeTo(tOut[0], 1)
+      closeTo(tOut[1], 2)
+      closeTo(tOut[2], 3)
+    })
+  })
+
+  describe('getReal / getDual', () => {
+    it('gets real part', () => {
+      const dq = new Quat2(1, 2, 3, 4, 5, 6, 7, 8)
+      const real = dq.getReal()
+      assert.strictEqual(real[0], 1)
+      assert.strictEqual(real[1], 2)
+      assert.strictEqual(real[2], 3)
+      assert.strictEqual(real[3], 4)
+    })
+    it('gets dual part', () => {
+      const dq = new Quat2(1, 2, 3, 4, 5, 6, 7, 8)
+      const dual = dq.getDual()
+      assert.strictEqual(dual[0], 5)
+      assert.strictEqual(dual[1], 6)
+      assert.strictEqual(dual[2], 7)
+      assert.strictEqual(dual[3], 8)
+    })
+  })
+
+  describe('multiply', () => {
+    it('identity * identity = identity', () => {
+      const a = Quat2.identity
+      const b = Quat2.identity
+      const out = new Quat2()
+      a.multiply(b, out)
+      closeTo(out[0], 0)
+      closeTo(out[1], 0)
+      closeTo(out[2], 0)
+      closeTo(out[3], 1)
+      closeTo(out[4], 0)
+      closeTo(out[5], 0)
+      closeTo(out[6], 0)
+      closeTo(out[7], 0)
+    })
+    it('combines rotation and translation', () => {
+      const rot = Quat2.fromRotation(Quat.fromAxisAngle(new Vec3(0, 1, 0), Math.PI / 2))
+      const trans = Quat2.fromTranslation(new Vec3(1, 0, 0))
+      const out = new Quat2()
+      rot.multiply(trans, out)
+      const t = out.getTranslation()
+      closeTo(t[0], 0, 1)
+      closeTo(t[2], -1, 1)
+    })
+  })
+
+  describe('translate', () => {
+    it('adds translation', () => {
+      const dq = Quat2.fromTranslation(new Vec3(1, 0, 0))
+      const r = dq.translate(new Vec3(0, 2, 0))
+      const t = r.getTranslation()
+      closeTo(t[0], 1)
+      closeTo(t[1], 2)
+      closeTo(t[2], 0)
+    })
+  })
+
+  describe('conjugate', () => {
+    it('negates xyz of both parts, keeps w', () => {
+      const dq = new Quat2(1, 2, 3, 4, 5, 6, 7, 8)
+      const out = new Quat2()
+      dq.conjugate(out)
+      assert.strictEqual(out[0], -1)
+      assert.strictEqual(out[1], -2)
+      assert.strictEqual(out[2], -3)
+      assert.strictEqual(out[3], 4)
+      assert.strictEqual(out[4], -5)
+      assert.strictEqual(out[5], -6)
+      assert.strictEqual(out[6], -7)
+      assert.strictEqual(out[7], 8)
+    })
+  })
+
+  describe('normalize', () => {
+    it('normalizes the dual quaternion', () => {
+      const dq = Quat2.fromRotationTranslation(Quat.identity, new Vec3(1, 2, 3))
+      dq.normalize()
+      const len = Math.sqrt(dq[0]*dq[0] + dq[1]*dq[1] + dq[2]*dq[2] + dq[3]*dq[3])
+      closeTo(len, 1)
+    })
+  })
+
+  describe('clone', () => {
+    it('creates independent copy', () => {
+      const a = new Quat2(1, 2, 3, 4, 5, 6, 7, 8)
+      const b = a.clone()
+      a[0] = 99
+      assert.strictEqual(b[0], 1)
+    })
+  })
+
+  describe('equals / exactEquals', () => {
+    it('equals returns true for same values', () => {
+      const a = new Quat2(1, 2, 3, 4, 5, 6, 7, 8)
+      const b = new Quat2(1, 2, 3, 4, 5, 6, 7, 8)
+      assert.strictEqual(a.equals(b), true)
+    })
+    it('exactEquals returns false for different values', () => {
+      const a = new Quat2(1, 2, 3, 4, 5, 6, 7, 8)
+      const b = new Quat2(1, 2, 3, 4, 5, 6, 7, 9)
+      assert.strictEqual(a.exactEquals(b), false)
+    })
+  })
+
+  describe('toString', () => {
+    it('uses dual number notation', () => {
+      const dq = Quat2.identity
+      const s = dq.toString()
+      assert.ok(s.includes('ε'))
+    })
+  })
+
+  describe('lerp', () => {
+    it('interpolates at t=0 returns a', () => {
+      const a = Quat2.fromTranslation(new Vec3(0, 0, 0))
+      const b = Quat2.fromTranslation(new Vec3(10, 0, 0))
+      const out = Quat2.lerp(a, b, 0)
+      closeTo(out.getTranslation()[0], 0)
+    })
+    it('interpolates at t=1 returns b', () => {
+      const a = Quat2.fromTranslation(new Vec3(0, 0, 0))
+      const b = Quat2.fromTranslation(new Vec3(10, 0, 0))
+      const out = Quat2.lerp(a, b, 1)
+      closeTo(out.getTranslation()[0], 10)
+    })
+  })
+
+  describe('dot', () => {
+    it('computes dot product of real parts', () => {
+      const a = Quat2.identity
+      const b = Quat2.identity
+      closeTo(Quat2.dot(a, b), 1)
+    })
+  })
+})