@thi.ng/matrices 2.2.12 → 2.2.14

package/mulv.js

@@ -1,82 +1,63 @@
 import { dotS2, dotS3, dotS4 } from "@thi.ng/vectors/dots";
 import { setC2, setC3, setC4 } from "@thi.ng/vectors/setc";
 import { vop } from "@thi.ng/vectors/vop";
-/**
- * Matrix-vector multiplication. Supports in-place modification, i.e. if
- * `out === v`.
- *
- * @param out -
- * @param m -
- * @param v -
- */
-export const mulV = vop(1);
-/**
- * Multiplies 2x2 matrix `m` with 2D vector `v`. Supports in-place
- * modification, i.e. if `out === v`.
- *
- * @param out -
- * @param m -
- * @param v -
- */
-export const mulV22 = mulV.add(4, (out, m, v) => setC2(out || v, dotS2(m, v, 0, 0, 2), dotS2(m, v, 1, 0, 2)));
-/**
- * Multiplies 2x3 matrix `m` with 2D vector `v`. Supports in-place
- * modification, i.e. if `out === v`.
- *
- * @param out -
- * @param m -
- * @param v -
- */
-export const mulV23 = mulV.add(6, (out, m, v) => setC2(out || v, dotS2(m, v, 0, 0, 2) + m[4], dotS2(m, v, 1, 0, 2) + m[5]));
-/**
- * Multiplies 3x3 matrix `m` with 3D vector `v`. Supports in-place
- * modification, i.e. if `out === v`.
- *
- * @param out -
- * @param m -
- * @param v -
- */
-export const mulV33 = mulV.add(9, (out, m, v) => setC3(out || v, dotS3(m, v, 0, 0, 3), dotS3(m, v, 1, 0, 3), dotS3(m, v, 2, 0, 3)));
-/**
- * Multiplies 4x4 matrix `m` with 4D vector `v`. Supports in-place
- * modification, i.e. if `out === v`.
- *
- * @param out -
- * @param m -
- * @param v -
- */
-export const mulV44 = mulV.add(16, (out, m, v) => setC4(out || v, dotS4(m, v, 0, 0, 4), dotS4(m, v, 1, 0, 4), dotS4(m, v, 2, 0, 4), dotS4(m, v, 3, 0, 4)));
-/**
- * Multiplies 4x4 matrix `m` with 3D vector `v` and assumes initial
- * `w=1`, i.e. the vector is interpreted as `[x,y,z,1]`. After
- * transformation applies perspective divide of the resulting XYZ
- * components. Returns `undefined` if the computed perspective divisor
- * is zero (and would cause `NaN` results).
- *
- * @param out -
- * @param m -
- * @param v -
- */
-export const mulV344 = (out, m, v) => {
-    const w = dotS3(m, v, 3, 0, 4) + m[15];
-    return w !== 0
-        ? setC3(out || v, (dotS3(m, v, 0, 0, 4) + m[12]) / w, (dotS3(m, v, 1, 0, 4) + m[13]) / w, (dotS3(m, v, 2, 0, 4) + m[14]) / w)
-        : undefined;
+const mulV = vop(1);
+const mulV22 = mulV.add(
+  4,
+  (out, m, v) => setC2(out || v, dotS2(m, v, 0, 0, 2), dotS2(m, v, 1, 0, 2))
+);
+const mulV23 = mulV.add(
+  6,
+  (out, m, v) => setC2(out || v, dotS2(m, v, 0, 0, 2) + m[4], dotS2(m, v, 1, 0, 2) + m[5])
+);
+const mulV33 = mulV.add(
+  9,
+  (out, m, v) => setC3(
+    out || v,
+    dotS3(m, v, 0, 0, 3),
+    dotS3(m, v, 1, 0, 3),
+    dotS3(m, v, 2, 0, 3)
+  )
+);
+const mulV44 = mulV.add(
+  16,
+  (out, m, v) => setC4(
+    out || v,
+    dotS4(m, v, 0, 0, 4),
+    dotS4(m, v, 1, 0, 4),
+    dotS4(m, v, 2, 0, 4),
+    dotS4(m, v, 3, 0, 4)
+  )
+);
+const mulV344 = (out, m, v) => {
+  const w = dotS3(m, v, 3, 0, 4) + m[15];
+  return w !== 0 ? setC3(
+    out || v,
+    (dotS3(m, v, 0, 0, 4) + m[12]) / w,
+    (dotS3(m, v, 1, 0, 4) + m[13]) / w,
+    (dotS3(m, v, 2, 0, 4) + m[14]) / w
+  ) : void 0;
 };
-/**
- * Multiplies quaternion `q` with 3D vector `v`. Returns transformed
- * vector or modifies in-place if `out` is null or `v`.
- *
- * @param out -
- * @param q -
- * @param v -
- */
-export const mulVQ = (out, q, v) => {
-    const { 0: px, 1: py, 2: pz } = v;
-    const { 0: qx, 1: qy, 2: qz, 3: qw } = q;
-    const ix = qw * px + qy * pz - qz * py;
-    const iy = qw * py + qz * px - qx * pz;
-    const iz = qw * pz + qx * py - qy * px;
-    const iw = -qx * px - qy * py - qz * pz;
-    return setC3(out || v, ix * qw + iw * -qx + iy * -qz - iz * -qy, iy * qw + iw * -qy + iz * -qx - ix * -qz, iz * qw + iw * -qz + ix * -qy - iy * -qx);
+const mulVQ = (out, q, v) => {
+  const { 0: px, 1: py, 2: pz } = v;
+  const { 0: qx, 1: qy, 2: qz, 3: qw } = q;
+  const ix = qw * px + qy * pz - qz * py;
+  const iy = qw * py + qz * px - qx * pz;
+  const iz = qw * pz + qx * py - qy * px;
+  const iw = -qx * px - qy * py - qz * pz;
+  return setC3(
+    out || v,
+    ix * qw + iw * -qx + iy * -qz - iz * -qy,
+    iy * qw + iw * -qy + iz * -qx - ix * -qz,
+    iz * qw + iw * -qz + ix * -qy - iy * -qx
+  );
+};
+export {
+  mulV,
+  mulV22,
+  mulV23,
+  mulV33,
+  mulV344,
+  mulV44,
+  mulVQ
 };

package/mulvm.js

@@ -1,49 +1,19 @@
 import { dot2, dot3, dot4 } from "@thi.ng/vectors/dot";
 import { dotS2, dotS3, dotS4 } from "@thi.ng/vectors/dots";
 import { setC2, setC3, setC4 } from "@thi.ng/vectors/setc";
-/**
- * Same as:
- *
- * @example
- * ```ts
- * out[0] = dot(v, column(m, 0))
- * out[1] = dot(v, column(m, 1))
- * ```
- *
- * @param out -
- * @param v -
- * @param m -
- */
-export const mulVM22 = (out, v, m) => setC2(out, dot2(v, m), dotS2(v, m, 0, 2));
-export const mulVM23 = mulVM22;
-/**
- * Same as:
- *
- * @example
- * ```ts
- * out[0] = dot(v, column(m, 0))
- * out[1] = dot(v, column(m, 1))
- * out[2] = dot(v, column(m, 2))
- * ```
- *
- * @param out -
- * @param v -
- * @param m -
- */
-export const mulVM33 = (out, v, m) => setC3(out, dot3(v, m), dotS3(v, m, 0, 3), dotS3(v, m, 0, 6));
-/**
- * Same as:
- *
- * @example
- * ```ts
- * out[0] = dot(v, column(m, 0))
- * out[1] = dot(v, column(m, 1))
- * out[2] = dot(v, column(m, 2))
- * out[3] = dot(v, column(m, 3))
- * ```
- *
- * @param out -
- * @param v -
- * @param m -
- */
-export const mulVM44 = (out, v, m) => setC4(out, dot4(v, m), dotS4(v, m, 0, 4), dotS4(v, m, 0, 8), dotS4(v, m, 0, 12));
+const mulVM22 = (out, v, m) => setC2(out, dot2(v, m), dotS2(v, m, 0, 2));
+const mulVM23 = mulVM22;
+const mulVM33 = (out, v, m) => setC3(out, dot3(v, m), dotS3(v, m, 0, 3), dotS3(v, m, 0, 6));
+const mulVM44 = (out, v, m) => setC4(
+  out,
+  dot4(v, m),
+  dotS4(v, m, 0, 4),
+  dotS4(v, m, 0, 8),
+  dotS4(v, m, 0, 12)
+);
+export {
+  mulVM22,
+  mulVM23,
+  mulVM33,
+  mulVM44
+};

package/normal-mat.js

@@ -1,28 +1,15 @@
 import { invert33, invert44 } from "./invert.js";
 import { mat44to33 } from "./m44-m33.js";
 import { transpose33, transpose44 } from "./transpose.js";
-/**
- * Converts given 4x4 matrix to a 3x3 normal matrix, i.e. the transposed
- * inverse of its upper-left 3x3 region. If `out` is null a new result
- * matrix will be created. Returns `undefined` if matrix inversion
- * failed.
- *
- * @param out -
- * @param m -
- */
-export const normal33 = (out, m) => {
-    out = invert33(null, mat44to33(out, m));
-    return out ? transpose33(null, out) : undefined;
+const normal33 = (out, m) => {
+  out = invert33(null, mat44to33(out, m));
+  return out ? transpose33(null, out) : void 0;
 };
-/**
- * Converts given 4x4 matrix to a 4x4 matrix normal matrix, i.e. the
- * transposed inverse. Writes results to `m` if `out` is null. Returns
- * `undefined` if matrix inversion failed.
- *
- * @param out -
- * @param m -
- */
-export const normal44 = (out, m) => {
-    out = invert44(out, m);
-    return out ? transpose44(null, out) : undefined;
+const normal44 = (out, m) => {
+  out = invert44(out, m);
+  return out ? transpose44(null, out) : void 0;
+};
+export {
+  normal33,
+  normal44
 };

package/orthagonal.js

@@ -1,29 +1,21 @@
 import { EPS } from "@thi.ng/math/api";
 import { eqDelta } from "@thi.ng/math/eqdelta";
-/**
- * Returns true, if given square matrix of size `n` is orthagonal, i.e. check if
- * `A * AT = I`.
- *
- * https://en.wikipedia.org/wiki/Orthogonal_matrix
- *
- * @param m -
- * @param n -
- * @param eps -
- */
-export const isOrthagonal = (m, n, eps = EPS) => {
-    for (let i = 0; i < n; i++) {
-        const ii = i * n;
-        for (let j = 0; j < n; j++) {
-            const jj = j * n;
-            let acc = 0;
-            for (let k = 0; k < n; k++) {
-                acc += m[ii + k] * m[jj + k];
-            }
-            if ((i == j && !eqDelta(acc, 1, eps)) ||
-                (i != j && !eqDelta(acc, 0, eps))) {
-                return false;
-            }
-        }
+const isOrthagonal = (m, n, eps = EPS) => {
+  for (let i = 0; i < n; i++) {
+    const ii = i * n;
+    for (let j = 0; j < n; j++) {
+      const jj = j * n;
+      let acc = 0;
+      for (let k = 0; k < n; k++) {
+        acc += m[ii + k] * m[jj + k];
+      }
+      if (i == j && !eqDelta(acc, 1, eps) || i != j && !eqDelta(acc, 0, eps)) {
+        return false;
+      }
     }
-    return true;
+  }
+  return true;
+};
+export {
+  isOrthagonal
 };

package/ortho.js

@@ -1,19 +1,28 @@
 import { setC } from "@thi.ng/vectors/setc";
-/**
- * Creates a 4x4 matrix orthographic projection matrix and writes result
- * to `out`.
- *
- * @param out -
- * @param left -
- * @param right -
- * @param bottom -
- * @param top -
- * @param near -
- * @param far -
- */
-export const ortho = (out, left, right, bottom, top, near, far) => {
-    const dx = 1 / (right - left);
-    const dy = 1 / (top - bottom);
-    const dz = 1 / (far - near);
-    return setC(out || [], 2 * dx, 0, 0, 0, 0, 2 * dy, 0, 0, 0, 0, -2 * dz, 0, -(left + right) * dx, -(top + bottom) * dy, -(far + near) * dz, 1);
+const ortho = (out, left, right, bottom, top, near, far) => {
+  const dx = 1 / (right - left);
+  const dy = 1 / (top - bottom);
+  const dz = 1 / (far - near);
+  return setC(
+    out || [],
+    2 * dx,
+    0,
+    0,
+    0,
+    0,
+    2 * dy,
+    0,
+    0,
+    0,
+    0,
+    -2 * dz,
+    0,
+    -(left + right) * dx,
+    -(top + bottom) * dy,
+    -(far + near) * dz,
+    1
+  );
+};
+export {
+  ortho
 };

package/outer-product.js

@@ -1,12 +1,50 @@
 import { setC, setC4 } from "@thi.ng/vectors/setc";
 import { vop } from "@thi.ng/vectors/vop";
-/**
- * Computes outer/tensor product of vectors `u` and `v`. Returns square matrix
- * of same dimensions as vectors, e.g. 3x3 matrix for 3D vectors.
- *
- * https://en.wikipedia.org/wiki/Outer_product
- */
-export const outerProduct = vop(1);
-export const outerProduct2 = outerProduct.add(2, (out, [ux, uy], [vx, vy]) => setC4(out || [], ux * vx, uy * vx, ux * vy, uy * vy));
-export const outerProduct3 = outerProduct.add(3, (out, [ux, uy, uz], [vx, vy, vz]) => setC(out || [], ux * vx, uy * vx, uz * vx, ux * vy, uy * vy, uz * vy, ux * vz, uy * vz, uz * vz));
-export const outerProduct4 = outerProduct.add(4, (out, [ux, uy, uz, uw], [vx, vy, vz, vw]) => setC(out || [], ux * vx, uy * vx, uz * vx, uw * vx, ux * vy, uy * vy, uz * vy, uw * vy, ux * vz, uy * vz, uz * vz, uw * vz, ux * vw, uy * vw, uz * vw, uw * vw));
+const outerProduct = vop(1);
+const outerProduct2 = outerProduct.add(
+  2,
+  (out, [ux, uy], [vx, vy]) => setC4(out || [], ux * vx, uy * vx, ux * vy, uy * vy)
+);
+const outerProduct3 = outerProduct.add(
+  3,
+  (out, [ux, uy, uz], [vx, vy, vz]) => setC(
+    out || [],
+    ux * vx,
+    uy * vx,
+    uz * vx,
+    ux * vy,
+    uy * vy,
+    uz * vy,
+    ux * vz,
+    uy * vz,
+    uz * vz
+  )
+);
+const outerProduct4 = outerProduct.add(
+  4,
+  (out, [ux, uy, uz, uw], [vx, vy, vz, vw]) => setC(
+    out || [],
+    ux * vx,
+    uy * vx,
+    uz * vx,
+    uw * vx,
+    ux * vy,
+    uy * vy,
+    uz * vy,
+    uw * vy,
+    ux * vz,
+    uy * vz,
+    uz * vz,
+    uw * vz,
+    ux * vw,
+    uy * vw,
+    uz * vw,
+    uw * vw
+  )
+);
+export {
+  outerProduct,
+  outerProduct2,
+  outerProduct3,
+  outerProduct4
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/matrices",
-  "version": "2.2.12",
+  "version": "2.2.14",
   "description": "Matrix & quaternion operations for 2D/3D geometry processing",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc compile",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,13 +35,14 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/math": "^5.7.6",
-    "@thi.ng/vectors": "^7.8.8"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/math": "^5.7.7",
+    "@thi.ng/vectors": "^7.8.10"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -270,5 +273,5 @@
     ],
     "year": 2018
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "22e36fa838e5431d40165384918b395603bbd92f\n"
 }

package/perspective.js

@@ -1,15 +1,8 @@
 import { frustum, frustumBounds } from "./frustum.js";
-/**
- * Creates a 4x4 matrix perspective projection matrix and writes result
- * to `out`.
- *
- * @param out -
- * @param fov -
- * @param aspect -
- * @param near -
- * @param far -
- */
-export const perspective = (out, fov, aspect, near, far) => {
-    const f = frustumBounds(fov, aspect, near, far);
-    return frustum(out, f.left, f.right, f.bottom, f.top, f.near, f.far);
+const perspective = (out, fov, aspect, near, far) => {
+  const f = frustumBounds(fov, aspect, near, far);
+  return frustum(out, f.left, f.right, f.bottom, f.top, f.near, f.far);
+};
+export {
+  perspective
 };

package/project.js

@@ -1,56 +1,25 @@
 import { fromHomogeneous4 } from "@thi.ng/vectors/homogeneous";
 import { invert23, invert44 } from "./invert.js";
 import { mulV23, mulV344, mulV44 } from "./mulv.js";
-/**
- * Transforms given point `p` (4D, homogeneous coordinates) with 4x4
- * matrix `mvp`, applies perspective divide and then transforms XY
- * components with 2x3 matrix `view` matrix. Returns 3D vector. The
- * result Z component can be used for depth sorting.
- *
- * @param out -
- * @param mvp - 4x4 matrix
- * @param view - 2x3 matrix
- * @param p -
- */
-export const project = (out, mvp, view, p) => (!out && (out = []),
-    mulV23(out, view, fromHomogeneous4(out, mulV44([], mvp, p))));
-/**
- * Same as {@link project}, but slightly faster and more convenient for
- * the most common use case of projecting a 3D input point (assumes
- * `w=1` for its homogeneous coordinate, i.e. `[x,y,z,1]`). Returns
- * `undefined` if the computed perspective divisor is zero (and would
- * cause in `NaN` results).
- *
- * @param out -
- * @param mvp - 4x4 matrix
- * @param view - 2x3 matrix
- * @param p -
- */
-export const project3 = (out, mvp, view, p) => {
-    !out && (out = []);
-    const q = mulV344(out, mvp, p);
-    return q ? mulV23(q, view, q) : undefined;
+const project = (out, mvp, view, p) => (!out && (out = []), mulV23(out, view, fromHomogeneous4(out, mulV44([], mvp, p))));
+const project3 = (out, mvp, view, p) => {
+  !out && (out = []);
+  const q = mulV344(out, mvp, p);
+  return q ? mulV23(q, view, q) : void 0;
 };
-/**
- * Reverse operation of {@link project3}. If `invert` is true (default:
- * false), both `mvp` and `view` matrices will be inverted first
- * (non-destructively), else they're both assumed to be inverted
- * already.
- *
- * @param out -
- * @param mvp - 4x4 matrix
- * @param view - 2x3 matrix
- * @param p -
- * @param invert -
- */
-export const unproject = (out, mvp, view, p, doInvert = false) => {
-    if (doInvert) {
-        const _mvp = invert44([], mvp);
-        const _view = invert23([], view);
-        if (!_mvp || !_view)
-            return;
-        mvp = _mvp;
-        view = _view;
-    }
-    return mulV344(out, mvp, mulV23([0, 0, p[2] * 2 - 1], view, p));
+const unproject = (out, mvp, view, p, doInvert = false) => {
+  if (doInvert) {
+    const _mvp = invert44([], mvp);
+    const _view = invert23([], view);
+    if (!_mvp || !_view)
+      return;
+    mvp = _mvp;
+    view = _view;
+  }
+  return mulV344(out, mvp, mulV23([0, 0, p[2] * 2 - 1], view, p));
+};
+export {
+  project,
+  project3,
+  unproject
 };

package/quat-axis-angle.js

@@ -1,27 +1,17 @@
 import { EPS } from "@thi.ng/math/api";
 import { normalize3, normalize4 } from "@thi.ng/vectors/normalize";
-/**
- * Computes a quaternion representing the rotation `theta` around
- * `axis`.
- *
- * @param axis -
- * @param theta -
- */
-export const quatFromAxisAngle = (axis, theta) => {
-    theta *= 0.5;
-    return normalize3([0, 0, 0, Math.cos(theta)], axis, Math.sin(theta));
+const quatFromAxisAngle = (axis, theta) => {
+  theta *= 0.5;
+  return normalize3([0, 0, 0, Math.cos(theta)], axis, Math.sin(theta));
 };
-/**
- * Decomposes quaternion into `[axis, theta]` tuple.
- *
- * @param quat -
- */
-export const quatToAxisAngle = (quat) => {
-    const n = normalize4([], quat);
-    const w = n[3];
-    const m = Math.sqrt(1 - w * w);
-    const theta = 2 * Math.acos(w);
-    return m > EPS
-        ? [[n[0] / m, n[1] / m, n[2] / m], theta]
-        : [[n[0], n[1], n[2]], theta];
+const quatToAxisAngle = (quat) => {
+  const n = normalize4([], quat);
+  const w = n[3];
+  const m = Math.sqrt(1 - w * w);
+  const theta = 2 * Math.acos(w);
+  return m > EPS ? [[n[0] / m, n[1] / m, n[2] / m], theta] : [[n[0], n[1], n[2]], theta];
+};
+export {
+  quatFromAxisAngle,
+  quatToAxisAngle
 };

package/quat-euler.js

@@ -2,23 +2,21 @@ import { X3, Y3, Z3 } from "@thi.ng/vectors/api";
 import { mulQ } from "./mulq.js";
 import { quatFromAxisAngle } from "./quat-axis-angle.js";
 const axisOrder = {
-    xyz: [X3, Y3, Z3],
-    yxz: [Y3, X3, Z3],
-    xzy: [X3, Z3, Y3],
-    zxy: [Z3, X3, Y3],
-    yzx: [Y3, Z3, X3],
-    zyx: [Z3, Y3, X3],
+  xyz: [X3, Y3, Z3],
+  yxz: [Y3, X3, Z3],
+  xzy: [X3, Z3, Y3],
+  zxy: [Z3, X3, Y3],
+  yzx: [Y3, Z3, X3],
+  zyx: [Z3, Y3, X3]
 };
-/**
- * Constructs a quaternion from given rotation angles in specified
- * `order`.
- *
- * @param order -
- * @param a -
- * @param b -
- * @param c -
- */
-export const quatFromEuler = (order, a, b, c) => {
-    const [aa, ab, ac] = axisOrder[order];
-    return mulQ(null, mulQ([], quatFromAxisAngle(aa, a), quatFromAxisAngle(ab, b)), quatFromAxisAngle(ac, c));
+const quatFromEuler = (order, a, b, c) => {
+  const [aa, ab, ac] = axisOrder[order];
+  return mulQ(
+    null,
+    mulQ([], quatFromAxisAngle(aa, a), quatFromAxisAngle(ab, b)),
+    quatFromAxisAngle(ac, c)
+  );
+};
+export {
+  quatFromEuler
 };