@woosh/meep-engine 2.43.1 → 2.43.3

package/core/geom/3d/tetrahedra/compute_bounding_simplex_3d.js

@@ -156,7 +156,7 @@ export function compute_bounding_simplex_3d(
         result, result_offset,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
-        SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c
+        SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
     );
     plane_computeConvex3PlaneIntersection(
         result, result_offset + 3,
@@ -168,7 +168,7 @@ export function compute_bounding_simplex_3d(
         result, result_offset + 6,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
-        SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
+        SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c
     );
     plane_computeConvex3PlaneIntersection(
         result, result_offset + 9,

package/core/geom/3d/tetrahedra/compute_bounding_simplex_3d.spec.js

@@ -22,10 +22,10 @@ test('planar containment, one point', () => {
 
     r.push(0, 0, 0);
 
-    expect(orient3d_fast(r, 1, 3, 2, 4)).toBeLessThan(0);
-    expect(orient3d_fast(r, 2, 3, 0, 4)).toBeLessThan(0);
-    expect(orient3d_fast(r, 3, 1, 0, 4)).toBeLessThan(0);
-    expect(orient3d_fast(r, 0, 1, 2, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 2, 3, 1, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 0, 3, 2, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 0, 1, 3, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 2, 1, 0, 4)).toBeLessThan(0);
 });
 
 test('positive padding results in larger simplex', () => {

package/core/geom/3d/tetrahedra/delaunay/Cavity.js

@@ -4,13 +4,50 @@ export class Cavity {
          *
          * @type {number[]}
          */
-        this.indices = [];
+        this.__deleted = [];
 
         /**
          *
          * @type {number}
          */
-        this.size = 0;
+        this.__deleted_size = 0;
+
+        /**
+         * 5-tuples
+         * @type {number[]}
+         * @private
+         */
+        this.__boundary = [];
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__boundary_size = 0;
+    }
+
+    /**
+     * Add boundary information
+     * @param vta
+     * @param node1
+     * @param node2
+     * @param node3
+     * @param bnd
+     */
+    push_boundary(vta, node1, node2, node3, bnd) {
+
+        const n = this.__boundary_size;
+
+        const n5 = n * 5;
+
+        this.__boundary[n5] = vta;
+        this.__boundary[n5 + 1] = node1;
+        this.__boundary[n5 + 2] = node2;
+        this.__boundary[n5 + 3] = node3;
+        this.__boundary[n5 + 4] = bnd;
+
+        this.__boundary_size++;
     }
 
     update() {
@@ -21,8 +58,8 @@ export class Cavity {
      *
      * @param {number} i
      */
-    push(i) {
-        this.indices[this.size++] = i;
+    push_deleted(i) {
+        this.__deleted[this.__deleted_size++] = i;
     }
 
     /**
@@ -31,10 +68,10 @@ export class Cavity {
      * @returns {boolean}
      */
     includes(i) {
-        const n = this.size;
+        const n = this.__deleted_size;
 
         for (let j = 0; j < n; j++) {
-            if (this.indices[j] === i) {
+            if (this.__deleted[j] === i) {
                 return true;
             }
         }
@@ -43,6 +80,7 @@ export class Cavity {
     }
 
     reset() {
-        this.size = 0;
+        this.__deleted_size = 0;
+        this.__boundary_size = 0;
     }
 }

package/core/geom/3d/tetrahedra/delaunay/compute_delaunay_tetrahedral_mesh.js

@@ -1,7 +1,14 @@
 //
 
 import { compute_bounding_simplex_3d } from "../compute_bounding_simplex_3d.js";
-import { TetrahedralMesh } from "../tetrahedra_collection.js";
+import { TetrahedralMesh } from "../TetrahedralMesh.js";
+import { tetrahedral_mesh_walk_toward_cavity } from "./tetrahedral_mesh_walk_toward_cavity.js";
+import { tetrahedral_mesh_compute_sub_determinant } from "./tetrahedral_mesh_compute_sub_determinant.js";
+import { Cavity } from "./Cavity.js";
+import { tetrahedral_mesh_compute_cavity2 } from "./tetrahedral_mesh_compute_cavity2.js";
+import { fill_in_a_cavity } from "./fill_in_a_cavity.js";
+import { debug_validate_mesh } from "./debug_validate_mesh.js";
+
 
 /**
  * @see https://en.wikipedia.org/wiki/Bowyer%E2%80%93Watson_algorithm
@@ -22,37 +29,65 @@ export function compute_delaunay_tetrahedral_mesh(input, n) {
      */
     const tetrahedron_count_upper_bound = Math.ceil((n * n - 3 * n - 2) / 2) + 7;
 
-    const tetrahedrons = new TetrahedralMesh(tetrahedron_count_upper_bound);
+    const mesh = new TetrahedralMesh(tetrahedron_count_upper_bound);
 
     if (n < 4) {
         // no mesh can be created, too few points
-        return tetrahedrons;
+        return mesh;
     }
 
+    const CAVITY = new Cavity();
+
     // TODO apply spatial sort to point, to get better cache locality
 
     // compute bounds over the input
+    const sub_determinants = new Float32Array(tetrahedron_count_upper_bound * 4);
     const points = new Float32Array((n + 4) * 3);
 
     points.set(input);
 
     /*
-     create super bounding volume
+     create bounding volume tetrahedron over input set
      */
     compute_bounding_simplex_3d(points, n * 3, points, n, 1);
 
-    tetrahedrons.append(points, n, n + 1, n + 2, n + 3);
+    const super_tet = mesh.allocate();
+
+    mesh.setVertexIndex(super_tet, 0, n);
+    mesh.setVertexIndex(super_tet, 1, n + 1);
+    mesh.setVertexIndex(super_tet, 2, n + 2);
+    mesh.setVertexIndex(super_tet, 3, n + 3);
+
+    // make circular references on neighbour (algorithm doesn't work otherwise)
+    // mesh.setNeighbour(super_tet, 0, super_tet << 2 | 0);
+    // mesh.setNeighbour(super_tet, 1, super_tet << 2 | 1);
+    // mesh.setNeighbour(super_tet, 2, super_tet << 2 | 2);
+    // mesh.setNeighbour(super_tet, 3, super_tet << 2 | 3);
+
+    tetrahedral_mesh_compute_sub_determinant(sub_determinants, 0, mesh, points, 0);
+
+    debug_validate_mesh(mesh, points);
 
     // add all points to the mesh
+    let current_tet = 0;
+
     for (let i = 0; i < n; i++) {
-        tetrahedrons.insertPoint(points, i);
+
+        current_tet = tetrahedral_mesh_walk_toward_cavity(mesh, points, current_tet, i);
+
+        tetrahedral_mesh_compute_cavity2(mesh, points, sub_determinants, CAVITY, current_tet, i);
+        // tetrahedral_mesh_compute_cavity(mesh, CAVITY, points, current_tet, i);
+
+        current_tet = fill_in_a_cavity(mesh, points, sub_determinants, CAVITY, current_tet);
+
     }
 
     // remove tetras formed by with the super bounding volume
-    tetrahedrons.removeTetrasConnectedToPoints(points, n, n + 3);
+    mesh.removeTetrasConnectedToPoints(points, n, n + 3);
 
 
-    return tetrahedrons;
-}
+    debug_validate_mesh(mesh, points);
 
+    return mesh;
+}
 

package/core/geom/3d/tetrahedra/delaunay/debug_validate_mesh.js

@@ -0,0 +1,19 @@
+import { validate_tetrahedral_mesh } from "../validate_tetrahedral_mesh.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>|Float32Array} points
+ */
+export function debug_validate_mesh(mesh, points) {
+    const problems = [];
+
+    function add(x) {
+        problems.push(x);
+    }
+
+    if (!validate_tetrahedral_mesh(mesh, points, add)) {
+        debugger;
+        console.error(problems.join('\n'));
+    }
+}

package/core/geom/3d/tetrahedra/delaunay/fill_in_a_cavity.js

@@ -0,0 +1,155 @@
+import { assert } from "../../../../assert.js";
+import { tetrahedral_mesh_compute_sub_determinant } from "./tetrahedral_mesh_compute_sub_determinant.js";
+import { array_copy } from "../../../../collection/array/copyArray.js";
+import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
+import { debug_validate_mesh } from "./debug_validate_mesh.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>|number[]|Float32Array} points
+ * @param {ArrayLike<number>|number[]|Float32Array} subdets
+ * @param {Cavity} cavity
+ * @param {number} cur_tet
+ * @returns {number} new current tet
+ */
+export function fill_in_a_cavity(mesh, points, subdets, cavity, cur_tet) {
+
+    let clength = cavity.__deleted_size; // cavity size
+    const blength = cavity.__boundary_size; // boundary size
+
+    assert.equal(blength & 1, 0, 'there is always a pair number of triangle on the boundary. N points, 2N triangle, 3N edges');
+
+    /*
+    Re-use tets that would be deleted, if there are not enough dead tets - allocate new ones as necessary
+     */
+    if (blength > clength) {
+
+        for (let i = clength; i < blength; i++) {
+            // allocate tets for the cavity filling, remember them inside the "deleted" set for now
+            cavity.__deleted[i] = mesh.allocate();
+        }
+
+        clength = blength;
+    }
+
+    const boundary = cavity.__boundary;
+    const start = clength - blength;
+
+    for (let i = 0; i < blength; i++) {
+        // go over the faces in the cavity boundary and matching tet that will be filling the space
+
+        const current_tet_index = cavity.__deleted[i + start];
+
+        const i5 = i * 5;
+
+        // write filling tet's corners
+        mesh.setVertexIndex(current_tet_index, 0, boundary[i5]); // "ball"/cavity center point is written here
+        mesh.setVertexIndex(current_tet_index, 1, boundary[i5 + 1]);
+        mesh.setVertexIndex(current_tet_index, 2, boundary[i5 + 2]);
+        mesh.setVertexIndex(current_tet_index, 3, boundary[i5 + 3]);
+
+        const encoded_boundary_tet = boundary[i5 + 4];
+
+        mesh.setNeighbour(current_tet_index, 0, encoded_boundary_tet); // connect opposing neighbour
+
+        const encoded_current_tet = current_tet_index << 2;
+
+        if (encoded_boundary_tet !== INVALID_NEIGHBOUR) {
+            // update neighbour
+            mesh.setNeighbour(encoded_boundary_tet >> 2, encoded_boundary_tet & 3, encoded_current_tet);
+        }
+
+        // boundary[i5 + 4] = encoded_current_tet;
+
+        // compute SubDet
+        tetrahedral_mesh_compute_sub_determinant(subdets, current_tet_index * 4, mesh, points, current_tet_index);
+    }
+
+    computeAdjacencies(mesh, cavity, start, blength);
+    // computeAdjacenciesSlow(mesh, cavity, start, blength);
+
+    debug_validate_mesh(mesh, points);
+
+    cavity.__boundary_size = 0;
+    cavity.__deleted_size = start;
+
+
+    return cavity.__deleted[start];
+
+}
+
+/**
+ * filling back the cavity
+ * N+2 point on the surface of the cavity
+ * 2N triangle on the surface of the cavity, x3 (4*0.5+1) data = 6N+9 uint64_t
+ * => enough place for the 3N edge x2 data = 6N uint64_t
+ * @param {TetrahedralMesh} mesh
+ * @param {Cavity} cavity
+ * @param {number} start
+ * @param {number} blength
+ */
+function computeAdjacencies(mesh, cavity, start, blength) {
+    const boundary = cavity.__boundary;
+
+    let tlength = 0;
+
+    const Tmp = boundary; // we know there is enough space...
+    const index = [2, 3, 1, 2];
+
+    for (let i = 0; i < blength; i++) {
+
+        const cur_tet = cavity.__deleted[start + i];
+
+        // pointer to the position of Node[0] in the Tmp array
+
+        for (let j = 0; j < 3; j++) {
+            // define the edge by the minimum vertex and the other
+            const n0 = mesh.getVertexIndex(cur_tet, index[j]);
+            const n1 = mesh.getVertexIndex(cur_tet, index[j + 1]);
+
+            const current_tet_neighbour_id = j + 1;
+            const encoded_current_tet = (cur_tet << 2) | (current_tet_neighbour_id & 3);
+
+            // linear searching/pushing into Tmp
+            let k = 0;
+            for (; k < tlength; k++) {
+                // this is the only nested loop... the one that cost it all
+
+                if (Tmp[k * 3] === n0 && Tmp[k * 3 + 1] === n1)
+                    // found a match, stop here
+                    break;
+            }
+
+            if (k === tlength) {
+                // we did not find it
+                const offset = tlength * 3;
+
+                // flip the edge order and store it. Neighbouring tet will have edge order reversed
+                Tmp[offset] = n1;
+                Tmp[offset + 1] = n0;
+
+                Tmp[offset + 2] = encoded_current_tet;
+
+                tlength++;
+            } else {
+                // we found the neighbour !
+                const encoded_pairValue = Tmp[k * 3 + 2];
+
+                mesh.setNeighbour(cur_tet, current_tet_neighbour_id, encoded_pairValue);
+                mesh.setNeighbour(encoded_pairValue >> 2, encoded_pairValue & 3, encoded_current_tet);
+
+                // reduce search space, there can only be one neighbour pair, after it's found we can remove the entry from lookup table
+                tlength--;
+
+                if (k < tlength) {
+                    // put the last entry in the one we just discovered
+                    array_copy(Tmp, tlength * 3, Tmp, k * 3, 3);
+                }
+            }
+        }
+    }
+
+    assert.equal(tlength, 0, 'Failed to compute adjacencies');
+
+}

package/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_compute_cavity2.js

@@ -0,0 +1,224 @@
+import { assert } from "../../../../assert.js";
+import { point_in_tetrahedron_circumsphere } from "../point_in_tetrahedron_circumsphere.js";
+import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
+
+
+/**
+ *
+ * @param {Cavity} cavity
+ * @param {TetrahedralMesh} mesh
+ * @param {number} tet
+ * @param {number} point_index
+ * @param {number} k0
+ * @param {number} k1
+ * @param {number} k2
+ * @param {number} k3
+ */
+function store_special(cavity, mesh, tet, point_index, k0, k1, k2, k3) {
+
+    const node_0 = mesh.getVertexIndex(tet, k0);
+    const node_1 = mesh.getVertexIndex(tet, k1);
+    const node_2 = mesh.getVertexIndex(tet, k2);
+
+    cavity.push_boundary(
+        point_index,
+        node_0,
+        node_1,
+        node_2,
+        mesh.getNeighbour(tet, k3),
+    );
+}
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {Cavity} cavity
+ * @param {number[]|Float32Array} points
+ * @param {Float32Array} subdets
+ * @param {number} containing_tetra tetrahedron that contains point
+ * @param {number} point_index point that forms the cavity
+ */
+export function tetrahedral_mesh_compute_cavity3(
+    mesh,
+    points,
+    subdets,
+    cavity,
+    containing_tetra,
+    point_index
+) {
+    assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
+
+    // add the tet to cavity
+    cavity.push_deleted(containing_tetra);
+    subdets[containing_tetra * 4 + 3] = -1;
+
+    for (let start = cavity.__deleted_size - 1; start < cavity.__deleted_size; start++) {
+        const cur_tet = cavity.__deleted[start];
+
+        for (let i = 0; i < 4; i++) {
+            const encoded_neighbour = mesh.getNeighbour(cur_tet, i);
+
+            const k0 = (1 << i) & 3;
+            const k1 = (i + 2) % 3;
+            const k2 = (~((i + 1) >> 1) & 2) + 1;
+            const k3 = i;
+
+            if (encoded_neighbour === INVALID_NEIGHBOUR) {
+                // no neighbour, include this side into boundary
+
+                const node_0 = mesh.getVertexIndex(cur_tet, k0);
+                const node_1 = mesh.getVertexIndex(cur_tet, k1);
+                const node_2 = mesh.getVertexIndex(cur_tet, k2);
+
+                if(i === 3 || node_2 >= node_1) {
+                    cavity.push_boundary(
+                        point_index,
+                        node_2,
+                        node_0,
+                        node_1,
+                        mesh.getNeighbour(cur_tet, k3),
+                    );
+                }else{
+                    cavity.push_boundary(
+                        point_index,
+                        node_0,
+                        node_1,
+                        node_2,
+                        mesh.getNeighbour(cur_tet, k3),
+                    );
+                }
+
+                continue;
+            }
+
+            const neighbour_index = encoded_neighbour >> 2;
+
+            if (subdets[neighbour_index * 4 + 3] === -1) {
+                // already visited
+                continue;
+            }
+
+            if (point_in_tetrahedron_circumsphere(
+                points,
+                mesh.getVertexIndex(neighbour_index, 0),
+                mesh.getVertexIndex(neighbour_index, 1),
+                mesh.getVertexIndex(neighbour_index, 2),
+                mesh.getVertexIndex(neighbour_index, 3),
+                point_index
+            ) < 0) {
+                // outside the cavity, meaning it defines boundary
+
+                const node_0 = mesh.getVertexIndex(cur_tet, k0);
+                const node_1 = mesh.getVertexIndex(cur_tet, k1);
+                const node_2 = mesh.getVertexIndex(cur_tet, k2);
+
+                if(i === 3 || node_2 >= node_1) {
+                    cavity.push_boundary(
+                        point_index,
+                        node_2,
+                        node_0,
+                        node_1,
+                        mesh.getNeighbour(cur_tet, k3),
+                    );
+                }else{
+                    cavity.push_boundary(
+                        point_index,
+                        node_0,
+                        node_1,
+                        node_2,
+                        mesh.getNeighbour(cur_tet, k3),
+                    );
+                }
+            } else {
+                //part of the cavity, remove
+                cavity.push_deleted(neighbour_index);
+                subdets[neighbour_index * 4 + 3] = -1;
+            }
+        }
+
+    }
+}
+
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {Cavity} cavity
+ * @param {number[]|Float32Array} points
+ * @param {Float32Array} subdets
+ * @param {number} containing_tetra tetrahedron that contains point
+ * @param {number} point_index point that forms the cavity
+ */
+export function tetrahedral_mesh_compute_cavity2(
+    mesh,
+    points,
+    subdets,
+    cavity,
+    containing_tetra,
+    point_index
+) {
+    assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
+
+    // add the tet to cavity
+    cavity.push_deleted(containing_tetra);
+    subdets[containing_tetra * 4 + 3] = -1;
+
+    for (let start = cavity.__deleted_size - 1; start < cavity.__deleted_size; start++) {
+        const cur_tet = cavity.__deleted[start];
+
+        for (let i = 0; i < 4; i++) {
+            const encoded_neighbour = mesh.getNeighbour(cur_tet, i);
+
+            const k0 = (1 << i) & 3;
+            const k1 = (i + 2) % 3;
+            const k2 = (~((i + 1) >> 1) & 2) + 1;
+            const k3 = i;
+
+            if (encoded_neighbour === INVALID_NEIGHBOUR) {
+                // no neighbour, include this side into boundary
+
+                cavity.push_boundary(
+                    point_index,
+                    mesh.getVertexIndex(cur_tet, k0),
+                    mesh.getVertexIndex(cur_tet, k1),
+                    mesh.getVertexIndex(cur_tet, k2),
+                    mesh.getNeighbour(cur_tet, k3),
+                );
+
+                continue;
+            }
+
+            const neighbour_index = encoded_neighbour >> 2;
+
+            if (subdets[neighbour_index * 4 + 3] === -1) {
+                // already visited
+                continue;
+            }
+
+            if (point_in_tetrahedron_circumsphere(
+                points,
+                mesh.getVertexIndex(neighbour_index, 0),
+                mesh.getVertexIndex(neighbour_index, 1),
+                mesh.getVertexIndex(neighbour_index, 2),
+                mesh.getVertexIndex(neighbour_index, 3),
+                point_index
+            ) < 0) {
+                // outside the cavity, meaning it defines boundary
+
+                cavity.push_boundary(
+                    point_index,
+                    mesh.getVertexIndex(cur_tet, k0),
+                    mesh.getVertexIndex(cur_tet, k1),
+                    mesh.getVertexIndex(cur_tet, k2),
+                    mesh.getNeighbour(cur_tet, k3),
+                );
+
+            } else {
+                //part of the cavity, remove
+                cavity.push_deleted(neighbour_index);
+                subdets[neighbour_index * 4 + 3] = -1;
+            }
+        }
+
+    }
+}

package/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_compute_sub_determinant.js

@@ -0,0 +1,77 @@
+/**
+ * Compute sub-determinants for a given tetrahedron
+ * NOTE: this implementation doesn't use GHOST vertices, all tets/vertices are assumed to be real and valid
+ * @see https://git.immc.ucl.ac.be/hextreme/hxt_seqdel/-/blob/master/src/hxt_tetrahedra.c#L754
+ * @param {number[]|Float32Array} result
+ * @param {number} result_offset
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]|Float32Array} points
+ * @param {number} tetrahedron_index
+ */
+export function tetrahedral_mesh_compute_sub_determinant(result, result_offset, mesh, points, tetrahedron_index) {
+    /*
+     NOTE: the code is re-ordered slightly and inlined for speed, re-ordering is mostly to reduce register pressure
+     */
+    const a_index = mesh.getVertexIndex(tetrahedron_index, 0);
+    const b_index = mesh.getVertexIndex(tetrahedron_index, 1);
+    const c_index = mesh.getVertexIndex(tetrahedron_index, 2);
+    const d_index = mesh.getVertexIndex(tetrahedron_index, 3);
+
+    // read out coordinates
+    const a3 = a_index * 3;
+    const b3 = b_index * 3;
+    const c3 = c_index * 3;
+    const d3 = d_index * 3;
+
+    const a_x = points[a3];
+    const a_y = points[a3 + 1];
+    const a_z = points[a3 + 2];
+
+    const b_x = points[b3];
+    const b_y = points[b3 + 1];
+    const b_z = points[b3 + 2];
+
+    // construct AB, AC, AD
+    const ab_x = b_x - a_x;
+    const ab_y = b_y - a_y;
+    const ab_z = b_z - a_z;
+
+    const c_x = points[c3];
+    const c_y = points[c3 + 1];
+    const c_z = points[c3 + 2];
+
+    const ac_x = c_x - a_x;
+    const ac_y = c_y - a_y;
+    const ac_z = c_z - a_z;
+
+    const d_x = points[d3];
+    const d_y = points[d3 + 1];
+    const d_z = points[d3 + 2];
+
+    const ad_x = d_x - a_x;
+    const ad_y = d_y - a_y;
+    const ad_z = d_z - a_z;
+
+    const ab_w = ab_x * ab_x + ab_y * ab_y + ab_z * ab_z;
+    const ac_w = ac_x * ac_x + ac_y * ac_y + ac_z * ac_z;
+    const ad_w = ad_x * ad_x + ad_y * ad_y + ad_z * ad_z;
+
+    const cd12 = ac_z * ad_y - ac_y * ad_z;
+    const db12 = ad_z * ab_y - ad_y * ab_z;
+    const bc12 = ab_z * ac_y - ab_y * ac_z;
+
+    const cd30 = ac_x * ad_w - ac_w * ad_x;
+    const db30 = ad_x * ab_w - ad_w * ab_x;
+    const bc30 = ab_x * ac_w - ab_w * ac_x;
+
+    // each subdet is a simple triple product
+    const subdet_0 = ab_w * cd12 + ac_w * db12 + ad_w * bc12;
+    const subdet_1 = ab_z * cd30 + ac_z * db30 + ad_z * bc30;
+    const subdet_2 = ab_y * cd30 + ac_y * db30 + ad_y * bc30;
+    const subdet_3 = ab_x * cd12 + ac_x * db12 + ad_x * bc12;
+
+    result[result_offset] = subdet_0;
+    result[result_offset + 1] = subdet_1;
+    result[result_offset + 2] = subdet_2;
+    result[result_offset + 3] = subdet_3;
+}