@vib3code/sdk 2.0.3-canary.590fbae → 2.0.3-canary.69d53b3

package/src/math/Mat4x4.js

@@ -18,6 +18,12 @@
 import { Vec4 } from './Vec4.js';
 
 export class Mat4x4 {
+    /**
+     * Internal token to skip initialization during construction
+     * @private
+     */
+    static UNINITIALIZED = {};
+
     /**
      * Create a new 4x4 matrix
      * Default is identity matrix
@@ -26,6 +32,8 @@ export class Mat4x4 {
     constructor(elements = null) {
         this.data = new Float32Array(16);
 
+        if (elements === Mat4x4.UNINITIALIZED) return;
+
         if (elements) {
             if (elements.length !== 16) {
                 throw new Error('Mat4x4 requires exactly 16 elements');
@@ -45,12 +53,7 @@ export class Mat4x4 {
      * @returns {Mat4x4}
      */
     static identity() {
-        return new Mat4x4([
-            1, 0, 0, 0,
-            0, 1, 0, 0,
-            0, 0, 1, 0,
-            0, 0, 0, 1
-        ]);
+        return new Mat4x4();
     }
 
     /**
@@ -58,7 +61,7 @@ export class Mat4x4 {
      * @returns {Mat4x4}
      */
     static zero() {
-        return new Mat4x4(new Float32Array(16));
+        return new Mat4x4(Mat4x4.UNINITIALIZED);
     }
 
     /**
@@ -157,10 +160,11 @@ export class Mat4x4 {
     /**
      * Multiply two matrices
      * @param {Mat4x4} m - Right operand
+     * @param {Mat4x4} [target=null] - Optional target matrix to store result
      * @returns {Mat4x4} New matrix = this * m
      */
-    multiply(m) {
-        const out = new Mat4x4();
+    multiply(m, target = null) {
+        const out = target || new Mat4x4(Mat4x4.UNINITIALIZED);
         const r = out.data;
         const a = this.data;
         const b = m.data;
@@ -259,16 +263,22 @@ export class Mat4x4 {
     /**
      * Transform a Vec4 by this matrix
      * @param {Vec4} v
+     * @param {Vec4} [target=null] - Optional target vector to store result
      * @returns {Vec4} Transformed vector
      */
-    multiplyVec4(v) {
+    multiplyVec4(v, target = null) {
         const m = this.data;
-        return new Vec4(
-            m[0] * v.x + m[4] * v.y + m[8] * v.z + m[12] * v.w,
-            m[1] * v.x + m[5] * v.y + m[9] * v.z + m[13] * v.w,
-            m[2] * v.x + m[6] * v.y + m[10] * v.z + m[14] * v.w,
-            m[3] * v.x + m[7] * v.y + m[11] * v.z + m[15] * v.w
-        );
+        const out = target || new Vec4();
+
+        // Cache components to support aliasing (target === v)
+        const x = v.x, y = v.y, z = v.z, w = v.w;
+
+        out.x = m[0] * x + m[4] * y + m[8] * z + m[12] * w;
+        out.y = m[1] * x + m[5] * y + m[9] * z + m[13] * w;
+        out.z = m[2] * x + m[6] * y + m[10] * z + m[14] * w;
+        out.w = m[3] * x + m[7] * y + m[11] * z + m[15] * w;
+
+        return out;
     }
 
     /**
@@ -310,27 +320,36 @@ export class Mat4x4 {
     /**
      * Add another matrix
      * @param {Mat4x4} m
+     * @param {Mat4x4} [target=null] - Optional target matrix
      * @returns {Mat4x4} New matrix
      */
-    add(m) {
-        const result = new Float32Array(16);
+    add(m, target = null) {
+        const out = target || new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        const a = this.data;
+        const b = m.data;
+
         for (let i = 0; i < 16; i++) {
-            result[i] = this.data[i] + m.data[i];
+            r[i] = a[i] + b[i];
         }
-        return new Mat4x4(result);
+        return out;
     }
 
     /**
      * Multiply by scalar
      * @param {number} s
+     * @param {Mat4x4} [target=null] - Optional target matrix
      * @returns {Mat4x4} New matrix
      */
-    scale(s) {
-        const result = new Float32Array(16);
+    scale(s, target = null) {
+        const out = target || new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        const a = this.data;
+
         for (let i = 0; i < 16; i++) {
-            result[i] = this.data[i] * s;
+            r[i] = a[i] * s;
         }
-        return new Mat4x4(result);
+        return out;
     }
 
     /**
@@ -339,12 +358,13 @@ export class Mat4x4 {
      */
     transpose() {
         const m = this.data;
-        return new Mat4x4([
-            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]
-        ]);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        r[0] = m[0]; r[4] = m[1]; r[8] = m[2]; r[12] = m[3];
+        r[1] = m[4]; r[5] = m[5]; r[9] = m[6]; r[13] = m[7];
+        r[2] = m[8]; r[6] = m[9]; r[10] = m[10]; r[14] = m[11];
+        r[3] = m[12]; r[7] = m[13]; r[11] = m[14]; r[15] = m[15];
+        return out;
     }
 
     /**
@@ -399,7 +419,8 @@ export class Mat4x4 {
      */
     inverse() {
         const m = this.data;
-        const inv = new Float32Array(16);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const inv = out.data;
 
         inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] +
             m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10];
@@ -460,7 +481,7 @@ export class Mat4x4 {
             inv[i] *= invDet;
         }
 
-        return new Mat4x4(inv);
+        return out;
     }
 
     /**
@@ -547,6 +568,122 @@ export class Mat4x4 {
         return new Mat4x4(json.data);
     }
 
+    // ========== IN-PLACE ROTATIONS ==========
+
+    /**
+     * Rotate in XY plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateXY(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a0 = m[i];      // Col 0
+            const a1 = m[i + 4];  // Col 1
+            m[i]     = a0 * c + a1 * s;
+            m[i + 4] = -a0 * s + a1 * c;
+        }
+        return this;
+    }
+
+    /**
+     * Rotate in XZ plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateXZ(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a0 = m[i];      // Col 0
+            const a2 = m[i + 8];  // Col 2
+            m[i]     = a0 * c - a2 * s;
+            m[i + 8] = a0 * s + a2 * c;
+        }
+        return this;
+    }
+
+    /**
+     * Rotate in YZ plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateYZ(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a1 = m[i + 4];  // Col 1
+            const a2 = m[i + 8];  // Col 2
+            m[i + 4] = a1 * c + a2 * s;
+            m[i + 8] = -a1 * s + a2 * c;
+        }
+        return this;
+    }
+
+    /**
+     * Rotate in XW plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateXW(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a0 = m[i];       // Col 0
+            const a3 = m[i + 12];  // Col 3
+            m[i]      = a0 * c + a3 * s;
+            m[i + 12] = -a0 * s + a3 * c;
+        }
+        return this;
+    }
+
+    /**
+     * Rotate in YW plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateYW(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a1 = m[i + 4];   // Col 1
+            const a3 = m[i + 12];  // Col 3
+            m[i + 4]  = a1 * c + a3 * s;
+            m[i + 12] = -a1 * s + a3 * c;
+        }
+        return this;
+    }
+
+    /**
+     * Rotate in ZW plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateZW(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a2 = m[i + 8];   // Col 2
+            const a3 = m[i + 12];  // Col 3
+            m[i + 8]  = a2 * c + a3 * s;
+            m[i + 12] = -a2 * s + a3 * c;
+        }
+        return this;
+    }
+
     // ========== ROTATION MATRICES FOR ALL 6 PLANES ==========
 
     /**
@@ -557,12 +694,13 @@ export class Mat4x4 {
     static rotationXY(angle) {
         const c = Math.cos(angle);
         const s = Math.sin(angle);
-        return new Mat4x4([
-            c, s, 0, 0,
-            -s, c, 0, 0,
-            0, 0, 1, 0,
-            0, 0, 0, 1
-        ]);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        r[0] = c; r[1] = s;
+        r[4] = -s; r[5] = c;
+        r[10] = 1;
+        r[15] = 1;
+        return out;
     }
 
     /**
@@ -573,12 +711,13 @@ export class Mat4x4 {
     static rotationXZ(angle) {
         const c = Math.cos(angle);
         const s = Math.sin(angle);
-        return new Mat4x4([
-            c, 0, -s, 0,
-            0, 1, 0, 0,
-            s, 0, c, 0,
-            0, 0, 0, 1
-        ]);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        r[0] = c; r[2] = -s;
+        r[5] = 1;
+        r[8] = s; r[10] = c;
+        r[15] = 1;
+        return out;
     }
 
     /**
@@ -589,12 +728,13 @@ export class Mat4x4 {
     static rotationYZ(angle) {
         const c = Math.cos(angle);
         const s = Math.sin(angle);
-        return new Mat4x4([
-            1, 0, 0, 0,
-            0, c, s, 0,
-            0, -s, c, 0,
-            0, 0, 0, 1
-        ]);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        r[0] = 1;
+        r[5] = c; r[6] = s;
+        r[9] = -s; r[10] = c;
+        r[15] = 1;
+        return out;
     }
 
     /**
@@ -606,12 +746,13 @@ export class Mat4x4 {
     static rotationXW(angle) {
         const c = Math.cos(angle);
         const s = Math.sin(angle);
-        return new Mat4x4([
-            c, 0, 0, s,
-            0, 1, 0, 0,
-            0, 0, 1, 0,
-            -s, 0, 0, c
-        ]);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        r[0] = c; r[3] = s;
+        r[5] = 1;
+        r[10] = 1;
+        r[12] = -s; r[15] = c;
+        return out;
     }
 
     /**
@@ -622,12 +763,13 @@ export class Mat4x4 {
     static rotationYW(angle) {
         const c = Math.cos(angle);
         const s = Math.sin(angle);
-        return new Mat4x4([
-            1, 0, 0, 0,
-            0, c, 0, s,
-            0, 0, 1, 0,
-            0, -s, 0, c
-        ]);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        r[0] = 1;
+        r[5] = c; r[7] = s;
+        r[10] = 1;
+        r[13] = -s; r[15] = c;
+        return out;
     }
 
     /**
@@ -638,12 +780,13 @@ export class Mat4x4 {
     static rotationZW(angle) {
         const c = Math.cos(angle);
         const s = Math.sin(angle);
-        return new Mat4x4([
-            1, 0, 0, 0,
-            0, 1, 0, 0,
-            0, 0, c, s,
-            0, 0, -s, c
-        ]);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        r[0] = 1;
+        r[5] = 1;
+        r[10] = c; r[11] = s;
+        r[14] = -s; r[15] = c;
+        return out;
     }
 
     /**
@@ -681,12 +824,12 @@ export class Mat4x4 {
     static rotationFromAngles(angles) {
         let result = Mat4x4.identity();
 
-        if (angles.xy) result = result.multiply(Mat4x4.rotationXY(angles.xy));
-        if (angles.xz) result = result.multiply(Mat4x4.rotationXZ(angles.xz));
-        if (angles.yz) result = result.multiply(Mat4x4.rotationYZ(angles.yz));
-        if (angles.xw) result = result.multiply(Mat4x4.rotationXW(angles.xw));
-        if (angles.yw) result = result.multiply(Mat4x4.rotationYW(angles.yw));
-        if (angles.zw) result = result.multiply(Mat4x4.rotationZW(angles.zw));
+        if (angles.xy) result.rotateXY(angles.xy);
+        if (angles.xz) result.rotateXZ(angles.xz);
+        if (angles.yz) result.rotateYZ(angles.yz);
+        if (angles.xw) result.rotateXW(angles.xw);
+        if (angles.yw) result.rotateYW(angles.yw);
+        if (angles.zw) result.rotateZW(angles.zw);
 
         return result;
     }
@@ -715,12 +858,13 @@ export class Mat4x4 {
      * @returns {Mat4x4}
      */
     static uniformScale(s) {
-        return new Mat4x4([
-            s, 0, 0, 0,
-            0, s, 0, 0,
-            0, 0, s, 0,
-            0, 0, 0, s
-        ]);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        r[0] = s;
+        r[5] = s;
+        r[10] = s;
+        r[15] = s;
+        return out;
     }
 
     /**
@@ -732,12 +876,13 @@ export class Mat4x4 {
      * @returns {Mat4x4}
      */
     static scale(sx, sy, sz, sw = 1) {
-        return new Mat4x4([
-            sx, 0, 0, 0,
-            0, sy, 0, 0,
-            0, 0, sz, 0,
-            0, 0, 0, sw
-        ]);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        r[0] = sx;
+        r[5] = sy;
+        r[10] = sz;
+        r[15] = sw;
+        return out;
     }
 
     /**
@@ -753,12 +898,13 @@ export class Mat4x4 {
     static translation(tx, ty, tz, tw = 0) {
         // For true 4D translation, you need 5D homogeneous coordinates
         // This is a placeholder that adds the translation to the W column
-        return new Mat4x4([
-            1, 0, 0, 0,
-            0, 1, 0, 0,
-            0, 0, 1, 0,
-            tx, ty, tz, 1 + tw
-        ]);
+        const out = new Mat4x4(Mat4x4.UNINITIALIZED);
+        const r = out.data;
+        r[0] = 1;
+        r[5] = 1;
+        r[10] = 1;
+        r[12] = tx; r[13] = ty; r[14] = tz; r[15] = 1 + tw;
+        return out;
     }
 }
 

package/src/math/Rotor4D.js

@@ -323,14 +323,17 @@ export class Rotor4D {
     /**
      * Rotate a 4D vector using sandwich product: v' = R v R†
      *
+     * Matrix math is inlined to avoid allocating a temporary Float32Array(16).
+     * Pass an optional target Vec4 to eliminate all allocations.
+     *
      * @param {Vec4} v - Vector to rotate
-     * @param {Vec4} [target] - Optional target vector to write result to
-     * @returns {Vec4} Rotated vector
+     * @param {Vec4} [target] - Optional pre-allocated Vec4 to write result into
+     * @returns {Vec4} Rotated vector (target if provided, otherwise new Vec4)
      */
     rotate(v, target) {
-        // Direct matrix multiplication without allocation
+        const x = v.x, y = v.y, z = v.z, w = v.w;
 
-        // Normalize components for stability (same as toMatrix)
+        // Normalize for numerical stability (same as toMatrix)
         const n = this.norm();
         const invN = n > 1e-10 ? 1 / n : 1;
 
@@ -343,7 +346,7 @@ export class Rotor4D {
         const zw = this.zw * invN;
         const xyzw = this.xyzw * invN;
 
-        // Pre-compute products
+        // Squared terms
         const s2 = s * s;
         const xy2 = xy * xy;
         const xz2 = xz * xz;
@@ -353,22 +356,20 @@ export class Rotor4D {
         const zw2 = zw * zw;
         const xyzw2 = xyzw * xyzw;
 
-        // Cross terms
+        // Cross terms (pre-multiplied by 2)
         const sxy = 2 * s * xy;
         const sxz = 2 * s * xz;
         const syz = 2 * s * yz;
         const sxw = 2 * s * xw;
         const syw = 2 * s * yw;
         const szw = 2 * s * zw;
-        // const sxyzw = 2 * s * xyzw; // Unused in rotation matrix
 
-        const xyxz = 2 * xy * xz;
+        const xzyz = 2 * xz * yz;
         const xyyz = 2 * xy * yz;
+        const xyxz = 2 * xy * xz;
         const xyxw = 2 * xy * xw;
         const xyyw = 2 * xy * yw;
-        // const xyzw_c = 2 * xy * zw; // Unused in rotation matrix
 
-        const xzyz = 2 * xz * yz;
         const xzxw = 2 * xz * xw;
         const xzyw = 2 * xz * yw;
         const xzzw = 2 * xz * zw;
@@ -388,40 +389,33 @@ export class Rotor4D {
         const ywxyzw = 2 * yw * xyzw;
         const zwxyzw = 2 * zw * xyzw;
 
-        // Matrix elements
-        // Col 0
-        const m00 = s2 - xy2 - xz2 + yz2 - xw2 + yw2 + zw2 - xyzw2;
-        const m01 = sxy + xzyz + xwyw - zwxyzw;
-        const m02 = sxz - xyyz + xwzw + ywxyzw;
-        const m03 = sxw - xyyw - xzzw - yzxyzw;
-
-        // Col 1
-        const m10 = -sxy + xzyz + xwyw + zwxyzw;
-        const m11 = s2 - xy2 + xz2 - yz2 + xw2 - yw2 + zw2 - xyzw2;
-        const m12 = syz + xyxz + ywzw - xwxyzw;
-        const m13 = syw + xyxw - yzzw + xzxyzw;
-
-        // Col 2
-        const m20 = -sxz - xyyz + xwzw - ywxyzw;
-        const m21 = -syz + xyxz + ywzw + xwxyzw;
-        const m22 = s2 + xy2 - xz2 - yz2 + xw2 + yw2 - zw2 - xyzw2;
-        const m23 = szw + xzxw + yzyw - xyxyzw;
-
-        // Col 3
-        const m30 = -sxw - xyyw - xzzw + yzxyzw;
-        const m31 = -syw + xyxw - yzzw - xzxyzw;
-        const m32 = -szw + xzxw + yzyw + xyxyzw;
-        const m33 = s2 + xy2 + xz2 + yz2 - xw2 - yw2 - zw2 - xyzw2;
-
-        const x = v.x;
-        const y = v.y;
-        const z = v.z;
-        const w = v.w;
-
-        const rx = m00 * x + m10 * y + m20 * z + m30 * w;
-        const ry = m01 * x + m11 * y + m21 * z + m31 * w;
-        const rz = m02 * x + m12 * y + m22 * z + m32 * w;
-        const rw = m03 * x + m13 * y + m23 * z + m33 * w;
+        // Column-major 4x4 rotation matrix entries (inlined from toMatrix)
+        // Column 0
+        const m0  = s2 - xy2 - xz2 + yz2 - xw2 + yw2 + zw2 - xyzw2;
+        const m1  = sxy + xzyz + xwyw - zwxyzw;
+        const m2  = sxz - xyyz + xwzw + ywxyzw;
+        const m3  = sxw - xyyw - xzzw - yzxyzw;
+        // Column 1
+        const m4  = -sxy + xzyz + xwyw + zwxyzw;
+        const m5  = s2 - xy2 + xz2 - yz2 + xw2 - yw2 + zw2 - xyzw2;
+        const m6  = syz + xyxz + ywzw - xwxyzw;
+        const m7  = syw + xyxw - yzzw + xzxyzw;
+        // Column 2
+        const m8  = -sxz - xyyz + xwzw - ywxyzw;
+        const m9  = -syz + xyxz + ywzw + xwxyzw;
+        const m10 = s2 + xy2 - xz2 - yz2 + xw2 + yw2 - zw2 - xyzw2;
+        const m11 = szw + xzxw + yzyw - xyxyzw;
+        // Column 3
+        const m12 = -sxw - xyyw - xzzw + yzxyzw;
+        const m13 = -syw + xyxw - yzzw - xzxyzw;
+        const m14 = -szw + xzxw + yzyw + xyxyzw;
+        const m15 = s2 + xy2 + xz2 + yz2 - xw2 - yw2 - zw2 - xyzw2;
+
+        // Matrix-vector multiply
+        const rx = m0 * x + m4 * y + m8  * z + m12 * w;
+        const ry = m1 * x + m5 * y + m9  * z + m13 * w;
+        const rz = m2 * x + m6 * y + m10 * z + m14 * w;
+        const rw = m3 * x + m7 * y + m11 * z + m15 * w;
 
         if (target) {
             target.x = rx;
@@ -430,15 +424,15 @@ export class Rotor4D {
             target.w = rw;
             return target;
         }
-
         return new Vec4(rx, ry, rz, rw);
     }
 
     /**
      * Convert rotor to 4x4 rotation matrix (column-major for WebGL)
+     * @param {Float32Array|Array} [target] - Optional target array to write into
      * @returns {Float32Array} 16-element array in column-major order
      */
-    toMatrix() {
+    toMatrix(target = null) {
         // Normalize first for numerical stability
         const n = this.norm();
         const invN = n > 1e-10 ? 1 / n : 1;
@@ -502,6 +496,35 @@ export class Rotor4D {
         // Formula derived from sandwich product R v R†
         // Diagonal: s² minus bivectors containing that axis, plus others
         // Off-diagonal: 2*s*bivector terms for single-plane contributions
+
+        if (target) {
+            // Column 0 (transformed X axis)
+            target[0] = s2 - xy2 - xz2 + yz2 - xw2 + yw2 + zw2 - xyzw2;
+            target[1] = sxy + xzyz + xwyw - zwxyzw;
+            target[2] = sxz - xyyz + xwzw + ywxyzw;
+            target[3] = sxw - xyyw - xzzw - yzxyzw;
+
+            // Column 1 (transformed Y axis)
+            target[4] = -sxy + xzyz + xwyw + zwxyzw;
+            target[5] = s2 - xy2 + xz2 - yz2 + xw2 - yw2 + zw2 - xyzw2;
+            target[6] = syz + xyxz + ywzw - xwxyzw;
+            target[7] = syw + xyxw - yzzw + xzxyzw;
+
+            // Column 2 (transformed Z axis)
+            target[8] = -sxz - xyyz + xwzw - ywxyzw;
+            target[9] = -syz + xyxz + ywzw + xwxyzw;
+            target[10] = s2 + xy2 - xz2 - yz2 + xw2 + yw2 - zw2 - xyzw2;
+            target[11] = szw + xzxw + yzyw - xyxyzw;
+
+            // Column 3 (transformed W axis)
+            target[12] = -sxw - xyyw - xzzw + yzxyzw;
+            target[13] = -syw + xyxw - yzzw - xzxyzw;
+            target[14] = -szw + xzxw + yzyw + xyxyzw;
+            target[15] = s2 + xy2 + xz2 + yz2 - xw2 - yw2 - zw2 - xyzw2;
+
+            return target;
+        }
+
         return new Float32Array([
             // Column 0 (transformed X axis)
             s2 - xy2 - xz2 + yz2 - xw2 + yw2 + zw2 - xyzw2,