@thi.ng/matrices 2.2.11 → 2.2.13

package/invert.js

@@ -5,53 +5,108 @@ import { vop } from "@thi.ng/vectors/vop";
 import { det44FromCoeffs, detCoeffs44 } from "./determinant.js";
 const dp4 = dotC4;
 const dp6 = dotC6;
-/**
- * Matrix inversion. Returns `undefined` if matrix is not invertible.
- * Mutates `mat` if `out` is `null`.
- *
- * @param out -
- * @param mat -
- */
-export const invert = vop(1);
-export const invert22 = invert.add(4, (out, m) => {
-    const [m00, m01, m10, m11] = m;
-    let det = dp4(m00, m11, -m01, m10);
-    if (det === 0)
-        return;
-    det = 1.0 / det;
-    return setC4(out || m, m11 * det, -m01 * det, -m10 * det, m00 * det);
+const invert = vop(1);
+const invert22 = invert.add(4, (out, m) => {
+  const [m00, m01, m10, m11] = m;
+  let det = dp4(m00, m11, -m01, m10);
+  if (det === 0)
+    return;
+  det = 1 / det;
+  return setC4(out || m, m11 * det, -m01 * det, -m10 * det, m00 * det);
 });
-export const invert23 = invert.add(6, (out, m) => {
-    const [m00, m01, m10, m11, m20, m21] = m;
-    let det = dp4(m00, m11, -m01, m10);
-    if (det === 0)
-        return;
-    det = 1.0 / det;
-    return setC6(out || m, m11 * det, -m01 * det, -m10 * det, m00 * det, dp4(m10, m21, -m11, m20) * det, dp4(m01, m20, -m00, m21) * det);
+const invert23 = invert.add(6, (out, m) => {
+  const [m00, m01, m10, m11, m20, m21] = m;
+  let det = dp4(m00, m11, -m01, m10);
+  if (det === 0)
+    return;
+  det = 1 / det;
+  return setC6(
+    out || m,
+    m11 * det,
+    -m01 * det,
+    -m10 * det,
+    m00 * det,
+    dp4(m10, m21, -m11, m20) * det,
+    dp4(m01, m20, -m00, m21) * det
+  );
 });
-export const invert33 = invert.add(9, (out, m) => {
-    const [m00, m01, m02, m10, m11, m12, m20, m21, m22] = m;
-    const d01 = dp4(m22, m11, -m12, m21);
-    const d11 = dp4(m12, m20, -m22, m10);
-    const d21 = dp4(m21, m10, -m11, m20);
-    let det = dp6(m00, d01, m01, d11, m02, d21);
-    if (det === 0)
-        return;
-    det = 1.0 / det;
-    return setC(out || m, d01 * det, dp4(-m22, m01, m02, m21) * det, dp4(m12, m01, -m02, m11) * det, d11 * det, dp4(m22, m00, -m02, m20) * det, dp4(-m12, m00, m02, m10) * det, d21 * det, dp4(-m21, m00, m01, m20) * det, dp4(m11, m00, -m01, m10) * det);
+const invert33 = invert.add(9, (out, m) => {
+  const [m00, m01, m02, m10, m11, m12, m20, m21, m22] = m;
+  const d01 = dp4(m22, m11, -m12, m21);
+  const d11 = dp4(m12, m20, -m22, m10);
+  const d21 = dp4(m21, m10, -m11, m20);
+  let det = dp6(m00, d01, m01, d11, m02, d21);
+  if (det === 0)
+    return;
+  det = 1 / det;
+  return setC(
+    out || m,
+    d01 * det,
+    dp4(-m22, m01, m02, m21) * det,
+    dp4(m12, m01, -m02, m11) * det,
+    d11 * det,
+    dp4(m22, m00, -m02, m20) * det,
+    dp4(-m12, m00, m02, m10) * det,
+    d21 * det,
+    dp4(-m21, m00, m01, m20) * det,
+    dp4(m11, m00, -m01, m10) * det
+  );
 });
-export const invert44 = invert.add(16, (out, m) => {
-    const coeffs = detCoeffs44(m);
-    let det = det44FromCoeffs(coeffs);
-    if (det === 0)
-        return;
-    det = 1.0 / det;
-    const [m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33,] = m;
-    const [d00, d01, d02, d03, d04, d05, d06, d07, d08, d09, d10, d11] = coeffs;
-    return setC(out || m, dp6(m11, d11, -m12, d10, m13, d09) * det, dp6(-m01, d11, m02, d10, -m03, d09) * det, dp6(m31, d05, -m32, d04, m33, d03) * det, dp6(-m21, d05, m22, d04, -m23, d03) * det, dp6(-m10, d11, m12, d08, -m13, d07) * det, dp6(m00, d11, -m02, d08, m03, d07) * det, dp6(-m30, d05, m32, d02, -m33, d01) * det, dp6(m20, d05, -m22, d02, m23, d01) * det, dp6(m10, d10, -m11, d08, m13, d06) * det, dp6(-m00, d10, m01, d08, -m03, d06) * det, dp6(m30, d04, -m31, d02, m33, d00) * det, dp6(-m20, d04, m21, d02, -m23, d00) * det, dp6(-m10, d09, m11, d07, -m12, d06) * det, dp6(m00, d09, -m01, d07, m02, d06) * det, dp6(-m30, d03, m31, d01, -m32, d00) * det, dp6(m20, d03, -m21, d01, m22, d00) * det);
+const invert44 = invert.add(16, (out, m) => {
+  const coeffs = detCoeffs44(m);
+  let det = det44FromCoeffs(coeffs);
+  if (det === 0)
+    return;
+  det = 1 / det;
+  const [
+    m00,
+    m01,
+    m02,
+    m03,
+    m10,
+    m11,
+    m12,
+    m13,
+    m20,
+    m21,
+    m22,
+    m23,
+    m30,
+    m31,
+    m32,
+    m33
+  ] = m;
+  const [d00, d01, d02, d03, d04, d05, d06, d07, d08, d09, d10, d11] = coeffs;
+  return setC(
+    out || m,
+    dp6(m11, d11, -m12, d10, m13, d09) * det,
+    dp6(-m01, d11, m02, d10, -m03, d09) * det,
+    dp6(m31, d05, -m32, d04, m33, d03) * det,
+    dp6(-m21, d05, m22, d04, -m23, d03) * det,
+    dp6(-m10, d11, m12, d08, -m13, d07) * det,
+    dp6(m00, d11, -m02, d08, m03, d07) * det,
+    dp6(-m30, d05, m32, d02, -m33, d01) * det,
+    dp6(m20, d05, -m22, d02, m23, d01) * det,
+    dp6(m10, d10, -m11, d08, m13, d06) * det,
+    dp6(-m00, d10, m01, d08, -m03, d06) * det,
+    dp6(m30, d04, -m31, d02, m33, d00) * det,
+    dp6(-m20, d04, m21, d02, -m23, d00) * det,
+    dp6(-m10, d09, m11, d07, -m12, d06) * det,
+    dp6(m00, d09, -m01, d07, m02, d06) * det,
+    dp6(-m30, d03, m31, d01, -m32, d00) * det,
+    dp6(m20, d03, -m21, d01, m22, d00) * det
+  );
 });
-export const invertQ = (out, a) => {
-    let d = magSq4(a);
-    d = d > 0 ? -1 / d : 0;
-    return setC4(out || a, a[0] * d, a[1] * d, a[2] * d, a[3] * -d);
+const invertQ = (out, a) => {
+  let d = magSq4(a);
+  d = d > 0 ? -1 / d : 0;
+  return setC4(out || a, a[0] * d, a[1] * d, a[2] * d, a[3] * -d);
+};
+export {
+  invert,
+  invert22,
+  invert23,
+  invert33,
+  invert44,
+  invertQ
 };

package/lookat.js

@@ -3,19 +3,30 @@ import { dot3 } from "@thi.ng/vectors/dot";
 import { normalize3 } from "@thi.ng/vectors/normalize";
 import { setC } from "@thi.ng/vectors/setc";
 import { sub3 } from "@thi.ng/vectors/sub";
-/**
- * Constructs a 4x4 camera matrix for given `eye` position, look-at
- * `target` (both in world space) and normalized `up` vector. Creates
- * new matrix if `out` is `null`.
- *
- * @param out -
- * @param eye -
- * @param target -
- * @param up -
- */
-export const lookAt = (out, eye, target, up) => {
-    const z = normalize3(null, sub3([], eye, target));
-    const x = normalize3(null, cross3([], up, z));
-    const y = normalize3(null, cross3([], z, x));
-    return setC(out || [], x[0], y[0], z[0], 0, x[1], y[1], z[1], 0, x[2], y[2], z[2], 0, -dot3(eye, x), -dot3(eye, y), -dot3(eye, z), 1);
+const lookAt = (out, eye, target, up) => {
+  const z = normalize3(null, sub3([], eye, target));
+  const x = normalize3(null, cross3([], up, z));
+  const y = normalize3(null, cross3([], z, x));
+  return setC(
+    out || [],
+    x[0],
+    y[0],
+    z[0],
+    0,
+    x[1],
+    y[1],
+    z[1],
+    0,
+    x[2],
+    y[2],
+    z[2],
+    0,
+    -dot3(eye, x),
+    -dot3(eye, y),
+    -dot3(eye, z),
+    1
+  );
+};
+export {
+  lookAt
 };

package/m22-m23.js

@@ -1,9 +1,5 @@
 import { set4 } from "@thi.ng/vectors/set";
-/**
- * Converts 2x2 to 2x3 matrix and writes result to `out`. Creates new
- * matrix if `out` is `null`.
- *
- * @param out -
- * @param m22 -
- */
-export const mat22to23 = (out, m22) => (!out && (out = []), set4(out, m22), (out[4] = out[5] = 0), out);
+const mat22to23 = (out, m22) => (!out && (out = []), set4(out, m22), out[4] = out[5] = 0, out);
+export {
+  mat22to23
+};

package/m23-m22.js

@@ -1,9 +1,5 @@
 import { set4 } from "@thi.ng/vectors/set";
-/**
- * Converts 2x3 to 2x2 matrix and writes result to `out`. Creates new
- * matrix if `out` is `null`.
- *
- * @param out -
- * @param m23 -
- */
-export const mat23to22 = (out, m23) => set4(out || [], m23);
+const mat23to22 = (out, m23) => set4(out || [], m23);
+export {
+  mat23to22
+};

package/m23-m44.js

@@ -1,17 +1,27 @@
 import { setC } from "@thi.ng/vectors/setc";
-/**
- * Converts 2x3 to 4x4 matrix and writes result to `out`. Creates new
- * matrix if `out` is `null`.
- *
- * @param out -
- * @param m23 -
- */
-export const mat23to44 = (out, m23) => setC(out || [], 
-// x
-m23[0], m23[1], 0, 0, 
-// y
-m23[2], m23[3], 0, 0, 
-// z
-0, 0, 1, 0, 
-// w
-m23[4], m23[5], 0, 1);
+const mat23to44 = (out, m23) => setC(
+  out || [],
+  // x
+  m23[0],
+  m23[1],
+  0,
+  0,
+  // y
+  m23[2],
+  m23[3],
+  0,
+  0,
+  // z
+  0,
+  0,
+  1,
+  0,
+  // w
+  m23[4],
+  m23[5],
+  0,
+  1
+);
+export {
+  mat23to44
+};

package/m33-m44.js

@@ -1,17 +1,27 @@
 import { setC } from "@thi.ng/vectors/setc";
-/**
- * Converts 3x3 to 4x4 matrix and writes result to `out`. Creates new
- * matrix if `out` is `null`.
- *
- * @param out -
- * @param m33 -
- */
-export const mat33to44 = (out, m33) => setC(out || [], 
-// x
-m33[0], m33[1], m33[2], 0, 
-// y
-m33[3], m33[4], m33[5], 0, 
-// z
-m33[6], m33[7], m33[8], 0, 
-// w
-0, 0, 0, 1);
+const mat33to44 = (out, m33) => setC(
+  out || [],
+  // x
+  m33[0],
+  m33[1],
+  m33[2],
+  0,
+  // y
+  m33[3],
+  m33[4],
+  m33[5],
+  0,
+  // z
+  m33[6],
+  m33[7],
+  m33[8],
+  0,
+  // w
+  0,
+  0,
+  0,
+  1
+);
+export {
+  mat33to44
+};

package/m44-m33.js

@@ -1,12 +1,5 @@
 import { setS3 } from "@thi.ng/vectors/sets";
-/**
- * Converts 4x4 to 3x3 matrix and writes result to `out`. Creates new
- * matrix if `out` is `null`.
- *
- * @param out -
- * @param m44 -
- */
-export const mat44to33 = (out, m44) => (!out && (out = []),
-    setS3(out, m44),
-    setS3(out, m44, 3, 4),
-    setS3(out, m44, 6, 8));
+const mat44to33 = (out, m44) => (!out && (out = []), setS3(out, m44), setS3(out, m44, 3, 4), setS3(out, m44, 6, 8));
+export {
+  mat44to33
+};

package/matn.js

@@ -1,5 +1,11 @@
 import { scale22, scale23, scale33, scale44 } from "./scale.js";
-export const mat22n = (out, n) => scale22(out, n);
-export const mat23n = (out, n) => scale23(out, n);
-export const mat33n = (out, n) => scale33(out, n);
-export const mat44n = (out, n) => scale44(out, [n, n, n, n]);
+const mat22n = (out, n) => scale22(out, n);
+const mat23n = (out, n) => scale23(out, n);
+const mat33n = (out, n) => scale33(out, n);
+const mat44n = (out, n) => scale44(out, [n, n, n, n]);
+export {
+  mat22n,
+  mat23n,
+  mat33n,
+  mat44n
+};

package/matv.js

@@ -1,37 +1,11 @@
 import { setVV16, setVV4, setVV6, setVV9 } from "@thi.ng/vectors/setvv";
-/**
- * Initializes 2x2 matrix from 2D column vectors.
- *
- * @param out -
- * @param x -
- * @param y -
- */
-export const mat22v = setVV4;
-/**
- * Initializes 2x3 matrix (affine transform) from 2D column vectors.
- *
- * @param out -
- * @param x -
- * @param y -
- * @param translate -
- */
-export const mat23v = setVV6;
-/**
- * Initializes 3x3 matrix from 3D column vectors.
- *
- * @param out -
- * @param x -
- * @param y -
- * @param z -
- */
-export const mat33v = setVV9;
-/**
- * Initializes 4x4 matrix from 4D column vectors.
- *
- * @param out -
- * @param x -
- * @param y -
- * @param z -
- * @param w -
- */
-export const mat44v = setVV16;
+const mat22v = setVV4;
+const mat23v = setVV6;
+const mat33v = setVV9;
+const mat44v = setVV16;
+export {
+  mat22v,
+  mat23v,
+  mat33v,
+  mat44v
+};

package/mixq.js

@@ -2,33 +2,23 @@ import { dot4 } from "@thi.ng/vectors/dot";
 import { maddN4 } from "@thi.ng/vectors/maddn";
 import { mulN4 } from "@thi.ng/vectors/muln";
 import { set4 } from "@thi.ng/vectors/set";
-/**
- * Interpolates quaternion `a` to `b` by given amount `t` [0...1], using
- * SLERP. Writes result to `out`. The optional `eps` (default 1e-3) is
- * used to switch to linear interpolation if the angular difference is
- * very small.
- *
- * @param out -
- * @param a -
- * @param b -
- * @param t -
- * @param eps -
- */
-export const mixQ = (out, a, b, t, eps = 1e-3) => {
-    const d = dot4(a, b);
-    if (Math.abs(d) < 1.0) {
-        const theta = Math.acos(d);
-        const stheta = Math.sqrt(1 - d * d);
-        let u, v;
-        if (Math.abs(stheta) < eps) {
-            u = v = 0.5;
-        }
-        else {
-            u = Math.sin(theta * (1 - t)) / stheta;
-            v = Math.sin(theta * t) / stheta;
-        }
-        !out && (out = a);
-        return maddN4(out, b, v, mulN4(out, a, u));
+const mixQ = (out, a, b, t, eps = 1e-3) => {
+  const d = dot4(a, b);
+  if (Math.abs(d) < 1) {
+    const theta = Math.acos(d);
+    const stheta = Math.sqrt(1 - d * d);
+    let u, v;
+    if (Math.abs(stheta) < eps) {
+      u = v = 0.5;
+    } else {
+      u = Math.sin(theta * (1 - t)) / stheta;
+      v = Math.sin(theta * t) / stheta;
     }
-    return a !== out ? set4(out, a) : out;
+    !out && (out = a);
+    return maddN4(out, b, v, mulN4(out, a, u));
+  }
+  return a !== out ? set4(out, a) : out;
+};
+export {
+  mixQ
 };

package/mul.js

@@ -1,17 +1,12 @@
 import { mul as _mul, mul4 } from "@thi.ng/vectors/mul";
 import { defMath } from "./compile/emit.js";
-/**
- * Componentwise matrix multiplication. Use {@link mulM} or
- * {@link concat} for actual matrix-matrix multiplication/concatenation.
- * If `out` is not given, writes result in `a`. Both input matrices MUST
- * be of same size.
- *
- * out = a * b
- *
- * @param out -
- * @param a -
- * @param b -
- */
-export const mul = _mul;
-export const mul22 = mul4;
-export const [mul23, mul33, mul44] = defMath(mul, "*");
+const mul = _mul;
+const mul22 = mul4;
+const [mul23, mul33, mul44] = defMath(mul, "*");
+export {
+  mul,
+  mul22,
+  mul23,
+  mul33,
+  mul44
+};

package/mulm.js

@@ -1,48 +1,70 @@
 import { dotS2, dotS3, dotS4 } from "@thi.ng/vectors/dots";
 import { setC, setC4, setC6 } from "@thi.ng/vectors/setc";
 import { vop } from "@thi.ng/vectors/vop";
-/**
- * Multi-method. Performs matrix-matrix multiplication. If `out` is not
- * given, writes result in `a`.
- *
- * @param out -
- * @param a -
- * @param b -
- */
-export const mulM = vop(1);
-/**
- * 2x2 matrix-matrix multiplication. If `out` is not given, writes
- * result in `a`.
- *
- * @param out -
- * @param a -
- * @param b -
- */
-export const mulM22 = mulM.add(4, (out, a, b) => setC4(out || a, dotS2(a, b, 0, 0, 2), dotS2(a, b, 1, 0, 2), dotS2(a, b, 0, 2, 2), dotS2(a, b, 1, 2, 2)));
-/**
- * 2x3 matrix-matrix multiplication. If `out` is not given, writes
- * result in `a`.
- *
- * @param out -
- * @param a -
- * @param b -
- */
-export const mulM23 = mulM.add(6, (out, a, b) => setC6(out || a, dotS2(a, b, 0, 0, 2), dotS2(a, b, 1, 0, 2), dotS2(a, b, 0, 2, 2), dotS2(a, b, 1, 2, 2), dotS2(a, b, 0, 4, 2) + a[4], dotS2(a, b, 1, 4, 2) + a[5]));
-/**
- * 3x3 matrix-matrix multiplication. If `out` is not given, writes
- * result in `a`.
- *
- * @param out -
- * @param a -
- * @param b -
- */
-export const mulM33 = mulM.add(9, (out, a, b) => setC(out || a, dotS3(a, b, 0, 0, 3), dotS3(a, b, 1, 0, 3), dotS3(a, b, 2, 0, 3), dotS3(a, b, 0, 3, 3), dotS3(a, b, 1, 3, 3), dotS3(a, b, 2, 3, 3), dotS3(a, b, 0, 6, 3), dotS3(a, b, 1, 6, 3), dotS3(a, b, 2, 6, 3)));
-/**
- * 4x4 matrix-matrix multiplication. If `out` is not given, writes
- * result in `a`.
- *
- * @param out -
- * @param a -
- * @param b -
- */
-export const mulM44 = mulM.add(16, (out, a, b) => setC(out || a, dotS4(a, b, 0, 0, 4), dotS4(a, b, 1, 0, 4), dotS4(a, b, 2, 0, 4), dotS4(a, b, 3, 0, 4), dotS4(a, b, 0, 4, 4), dotS4(a, b, 1, 4, 4), dotS4(a, b, 2, 4, 4), dotS4(a, b, 3, 4, 4), dotS4(a, b, 0, 8, 4), dotS4(a, b, 1, 8, 4), dotS4(a, b, 2, 8, 4), dotS4(a, b, 3, 8, 4), dotS4(a, b, 0, 12, 4), dotS4(a, b, 1, 12, 4), dotS4(a, b, 2, 12, 4), dotS4(a, b, 3, 12, 4)));
+const mulM = vop(1);
+const mulM22 = mulM.add(
+  4,
+  (out, a, b) => setC4(
+    out || a,
+    dotS2(a, b, 0, 0, 2),
+    dotS2(a, b, 1, 0, 2),
+    dotS2(a, b, 0, 2, 2),
+    dotS2(a, b, 1, 2, 2)
+  )
+);
+const mulM23 = mulM.add(
+  6,
+  (out, a, b) => setC6(
+    out || a,
+    dotS2(a, b, 0, 0, 2),
+    dotS2(a, b, 1, 0, 2),
+    dotS2(a, b, 0, 2, 2),
+    dotS2(a, b, 1, 2, 2),
+    dotS2(a, b, 0, 4, 2) + a[4],
+    dotS2(a, b, 1, 4, 2) + a[5]
+  )
+);
+const mulM33 = mulM.add(
+  9,
+  (out, a, b) => setC(
+    out || a,
+    dotS3(a, b, 0, 0, 3),
+    dotS3(a, b, 1, 0, 3),
+    dotS3(a, b, 2, 0, 3),
+    dotS3(a, b, 0, 3, 3),
+    dotS3(a, b, 1, 3, 3),
+    dotS3(a, b, 2, 3, 3),
+    dotS3(a, b, 0, 6, 3),
+    dotS3(a, b, 1, 6, 3),
+    dotS3(a, b, 2, 6, 3)
+  )
+);
+const mulM44 = mulM.add(
+  16,
+  (out, a, b) => setC(
+    out || a,
+    dotS4(a, b, 0, 0, 4),
+    dotS4(a, b, 1, 0, 4),
+    dotS4(a, b, 2, 0, 4),
+    dotS4(a, b, 3, 0, 4),
+    dotS4(a, b, 0, 4, 4),
+    dotS4(a, b, 1, 4, 4),
+    dotS4(a, b, 2, 4, 4),
+    dotS4(a, b, 3, 4, 4),
+    dotS4(a, b, 0, 8, 4),
+    dotS4(a, b, 1, 8, 4),
+    dotS4(a, b, 2, 8, 4),
+    dotS4(a, b, 3, 8, 4),
+    dotS4(a, b, 0, 12, 4),
+    dotS4(a, b, 1, 12, 4),
+    dotS4(a, b, 2, 12, 4),
+    dotS4(a, b, 3, 12, 4)
+  )
+);
+export {
+  mulM,
+  mulM22,
+  mulM23,
+  mulM33,
+  mulM44
+};

package/muln.js

@@ -1,15 +1,12 @@
 import { mulN as _mulN, mulN4 } from "@thi.ng/vectors/muln";
 import { defMathN } from "./compile/emit.js";
-/**
- * Multiplies matrix componentwise with single scalar. If `out` is not
- * given, writes result in `mat`.
- *
- * out = mat * n
- *
- * @param out -
- * @param mat -
- * @param n -
- */
-export const mulN = _mulN;
-export const mulN22 = mulN4;
-export const [mulN23, mulN33, mulN44] = defMathN(mulN, "*");
+const mulN = _mulN;
+const mulN22 = mulN4;
+const [mulN23, mulN33, mulN44] = defMathN(mulN, "*");
+export {
+  mulN,
+  mulN22,
+  mulN23,
+  mulN33,
+  mulN44
+};

package/mulq.js

@@ -1,14 +1,15 @@
 import { setC4 } from "@thi.ng/vectors/setc";
-/**
- * Performs quaternion multiplication of `a` and `b` and writes result
- * to `out`. If `out` is null, writes result into `a`.
- *
- * @param out -
- * @param a -
- * @param b -
- */
-export const mulQ = (out, a, b) => {
-    const { 0: ax, 1: ay, 2: az, 3: aw } = a;
-    const { 0: bx, 1: by, 2: bz, 3: bw } = b;
-    return setC4(out || a, ax * bw + aw * bx + ay * bz - az * by, ay * bw + aw * by + az * bx - ax * bz, az * bw + aw * bz + ax * by - ay * bx, aw * bw - ax * bx - ay * by - az * bz);
+const mulQ = (out, a, b) => {
+  const { 0: ax, 1: ay, 2: az, 3: aw } = a;
+  const { 0: bx, 1: by, 2: bz, 3: bw } = b;
+  return setC4(
+    out || a,
+    ax * bw + aw * bx + ay * bz - az * by,
+    ay * bw + aw * by + az * bx - ax * bz,
+    az * bw + aw * bz + ax * by - ay * bx,
+    aw * bw - ax * bx - ay * by - az * bz
+  );
+};
+export {
+  mulQ
 };