@woosh/meep-engine 2.120.0 → 2.120.2

package/src/core/geom/mat2/m2_is_diagonal.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number[]} m
+ * @param {number} [tolerance]
+ * @returns {boolean}
+ */
+export function m2_is_diagonal(m, tolerance = 1e-6) {
+    return Math.abs(m[1]) < tolerance && Math.abs(m[2]) < tolerance;
+}

package/src/core/geom/mat2/m2_is_orthogonal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if m * m^T is close to the identity matrix.
+ * @param {number[]} m
+ * @param {number} [tolerance]
+ * @returns {boolean}
+ */
+export function m2_is_orthogonal(m: number[], tolerance?: number): boolean;
+//# sourceMappingURL=m2_is_orthogonal.d.ts.map

package/src/core/geom/mat2/m2_is_orthogonal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m2_is_orthogonal.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/mat2/m2_is_orthogonal.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CAenB"}

package/src/core/geom/mat2/m2_is_orthogonal.js

@@ -0,0 +1,23 @@
+import { m2_multiply } from "./m2_multiply.js";
+import { m2_transpose } from "./m2_transpose.js";
+
+/**
+ * Check if m * m^T is close to the identity matrix.
+ * @param {number[]} m
+ * @param {number} [tolerance]
+ * @returns {boolean}
+ */
+export function m2_is_orthogonal(m, tolerance = 1e-6) {
+
+    const mt = m2_transpose([], m);
+    const m_mt = [];
+
+    m2_multiply(m_mt, m, mt);
+
+    return (
+        Math.abs(m_mt[0] - 1) < tolerance &&
+        Math.abs(m_mt[1]) < tolerance &&
+        Math.abs(m_mt[2]) < tolerance &&
+        Math.abs(m_mt[3] - 1) < tolerance
+    );
+}

package/src/core/geom/mat2/m2_transpose.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Transposes a 2x2 matrix, stored in a flattened array.
+ *
+ * @param {number[]} out Output: The transposed matrix. Can be the same array as `m`.
+ * @param {number[]} m Input: The 2x2 matrix to transpose, stored as a flattened array [a, b, c, d], representing [[a, c], [b, d]].
+ * @returns {number[]} The `out` parameter.
+ */
+export function m2_transpose(out: number[], m: number[]): number[];
+//# sourceMappingURL=m2_transpose.d.ts.map

package/src/core/geom/mat2/m2_transpose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m2_transpose.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/mat2/m2_transpose.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,kCAJW,MAAM,EAAE,KACR,MAAM,EAAE,GACN,MAAM,EAAE,CAWpB"}

package/src/core/geom/mat2/m2_transpose.js

@@ -0,0 +1,17 @@
+/**
+ * Transposes a 2x2 matrix, stored in a flattened array.
+ *
+ * @param {number[]} out Output: The transposed matrix. Can be the same array as `m`.
+ * @param {number[]} m Input: The 2x2 matrix to transpose, stored as a flattened array [a, b, c, d], representing [[a, c], [b, d]].
+ * @returns {number[]} The `out` parameter.
+ */
+export function m2_transpose(out, m) {
+    const b = m[1]; // Cache m[1] (which becomes m[2] after the swap)
+
+    out[0] = m[0];
+    out[1] = m[2];
+    out[2] = b; // Use the cached value
+    out[3] = m[3];
+
+    return out;
+}

package/src/core/graph/graph_compute_adjacency_matrix.d.ts

@@ -1,9 +1,11 @@
 /**
- * NOTE: does not clear matrix before writing adjacency
- * @template T
- * @param {Graph<T>} graph
- * @param {SquareMatrix} result
- * @param {Map<T,number>} node_indices
+ * Computes the adjacency matrix of a graph.
+ * Writes 1 to matrix elements where nodes are connected, leaves existing values where there are no connections.
+ * Does NOT zero-fill the matrix before writing.
+ * @template T Type of the graph's nodes.
+ * @param {Graph<T>} graph Input graph.
+ * @param {SquareMatrix} result Output: Adjacency matrix (modified in-place).
+ * @param {Map<T,number>} node_indices Map from graph nodes to matrix indices.
  */
 export function graph_compute_adjacency_matrix<T>(graph: Graph<T>, result: SquareMatrix, node_indices: Map<T, number>): void;
 //# sourceMappingURL=graph_compute_adjacency_matrix.d.ts.map

package/src/core/graph/graph_compute_adjacency_matrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_compute_adjacency_matrix.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/graph_compute_adjacency_matrix.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,+CALa,CAAC,SACH,KAAK,CAAC,CAAC,CAAC,UACR,YAAY,gBACZ,GAAG,CAAC,CAAC,EAAC,MAAM,CAAC,QAYvB"}
+{"version":3,"file":"graph_compute_adjacency_matrix.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/graph_compute_adjacency_matrix.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,+CALa,CAAC,SACH,KAAK,CAAC,CAAC,CAAC,UACR,YAAY,gBACZ,GAAG,CAAC,CAAC,EAAC,MAAM,CAAC,QAevB"}

package/src/core/graph/graph_compute_adjacency_matrix.js

@@ -1,11 +1,14 @@
+import { assert } from "../assert.js";
 
 
 /**
- * NOTE: does not clear matrix before writing adjacency
- * @template T
- * @param {Graph<T>} graph
- * @param {SquareMatrix} result
- * @param {Map<T,number>} node_indices
+ * Computes the adjacency matrix of a graph.
+ * Writes 1 to matrix elements where nodes are connected, leaves existing values where there are no connections.
+ * Does NOT zero-fill the matrix before writing.
+ * @template T Type of the graph's nodes.
+ * @param {Graph<T>} graph Input graph.
+ * @param {SquareMatrix} result Output: Adjacency matrix (modified in-place).
+ * @param {Map<T,number>} node_indices Map from graph nodes to matrix indices.
  */
 export function graph_compute_adjacency_matrix(graph, result, node_indices) {
     const edges = graph.getEdges();
@@ -14,6 +17,9 @@ export function graph_compute_adjacency_matrix(graph, result, node_indices) {
         const a = node_indices.get(edge.first);
         const b = node_indices.get(edge.second);
 
+        assert.isNonNegativeInteger(a, 'a');
+        assert.isNonNegativeInteger(b, 'b');
+
         result.setCellValue(a, b, 1);
         result.setCellValue(b, a, 1);
     }

package/src/core/graph/graph_compute_distance_matrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_compute_distance_matrix.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/graph_compute_distance_matrix.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,8CAPa,CAAC,SACH,KAAK,CAAC,CAAC,CAAC,cACR,CAAC,EAAE,WACH,MAAM,EAAE,kBACR,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GACZ,YAAY,CAyFxB;6BAnG4B,gCAAgC"}
+{"version":3,"file":"graph_compute_distance_matrix.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/graph_compute_distance_matrix.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,8CAPa,CAAC,SACH,KAAK,CAAC,CAAC,CAAC,cACR,CAAC,EAAE,WACH,MAAM,EAAE,kBACR,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GACZ,YAAY,CAgExB;6BA1E4B,gCAAgC"}

package/src/core/graph/graph_compute_distance_matrix.js

@@ -1,6 +1,5 @@
-import { BitSet } from "../binary/BitSet.js";
 import { BinaryDataType } from "../binary/type/BinaryDataType.js";
-import BinaryHeap from "../collection/heap/BinaryHeap.js";
+import { Deque } from "../collection/queue/Deque.js";
 import { SquareMatrix } from "../math/matrix/SquareMatrix.js";
 
 /**
@@ -18,86 +17,61 @@ export function graph_compute_distance_matrix(graph, node_array, targets, node_i
 
     const m_distances = new SquareMatrix(node_count, BinaryDataType.Float32);
 
-    const flags = BitSet.fixedSize(node_count);
-
     // initialize distances
     m_distances.fill(Number.POSITIVE_INFINITY);
 
-    let source_node;
+    // fill diagonal
+    for (let i = 0; i < node_count; i++) {
+        // Distance to self is 0
+        m_distances.setCellValue(i, i, 0);
+    }
 
     /**
      *
-     * @param {number} other_node
-     * @returns {number}
+     * @type {Deque<number>}
      */
-    function score(other_node) {
-        return m_distances.getCellValue(source_node, other_node);
-    }
-
-    for (let i = 0; i < targets.length; i++) {
-        source_node = targets[i];
-
-        // distance to self is always 0
-        m_distances.setCellValue(source_node, source_node, 0);
+    const queue = new Deque();
 
-        const heap = new BinaryHeap(score);
-        heap.push(source_node);
+    for (const target_index of targets) {
 
-        while (!heap.isEmpty()) {
-            const t = heap.pop();
+        queue.addLast(target_index);
 
-            const distance_to_this_node = m_distances.getCellValue(source_node, t);
-            if (flags.get(t)) {
-                // already visited
-                for (let v = 0; v < node_count; v++) {
-                    const shortcut_distance = distance_to_this_node + m_distances.getCellValue(t, v);
+        while (!queue.isEmpty()) {
+            const index_1 = queue.removeFirst();
+            const node_1 = node_array[index_1];
 
-                    if (shortcut_distance < m_distances.getCellValue(source_node, v)) {
-                        m_distances.setCellValue(source_node, v, shortcut_distance)
-                    }
+            const node_1_container = graph.getNodeContainer(node_1);
 
-                }
-            } else {
-                // not visited yet
-                const t_node = node_array[t];
-
-                const t_node_container = graph.getNodeContainer(t_node);
+            const edges = node_1_container.getEdges();
+            const edge_count = edges.length;
 
-                const node_edges = t_node_container.getEdges();
-                const node_edge_count = node_edges.length;
+            for (let i = 0; i < edge_count; i++) {
 
-                for (let i1 = 0; i1 < node_edge_count; i1++) {
+                const edge = edges[i];
 
-                    /**
-                     *
-                     * @type {WeightedEdge<N>}
-                     */
-                    const node_edge = node_edges[i1];
+                const node_0 = edge.other(node_1);
 
-                    const neighbour_node = node_edge.other(t_node);
+                if (!edge.validateTransition(node_0, node_1)) {
+                    continue;
+                }
 
-                    const neighbour_node_index = node_index_map.get(neighbour_node);
+                const index_0 = node_index_map.get(node_0);
 
-                    if (neighbour_node_index === -1) {
-                        // not in the input set
-                        continue;
-                    }
+                // If we haven't visited this neighbor yet, its distance is the current distance + 1
+                if (m_distances.getCellValue(index_0, target_index) === Number.POSITIVE_INFINITY) {
 
-                    const transition_cost = node_edge.weight + 1e-5;
+                    const transition_cost = edge.weight;
 
-                    const distance_to_neighbour = distance_to_this_node + transition_cost;
+                    const new_distance = m_distances.getCellValue(index_1, target_index) + transition_cost;
 
-                    if (distance_to_neighbour < m_distances.getCellValue(source_node, neighbour_node_index)) {
-                        m_distances.setCellValue(source_node, neighbour_node_index, distance_to_neighbour);
+                    m_distances.setCellValue(index_0, target_index, new_distance);
 
-                        heap.push(neighbour_node_index);
-                    }
+                    queue.addLast(index_0);
                 }
             }
         }
-
-        flags.set(source_node, true);
     }
 
+
     return m_distances;
 }

package/src/core/graph/graph_compute_laplacian_matrix.d.ts

@@ -1,10 +1,10 @@
 /**
- * Laplacian matrix (graph Laplacian)
- * NOTE: does not clear matrix before writing
- * @template T
- * @param {Graph<T>} graph
- * @param {SquareMatrix} result
- * @param {Map<T,number>} node_indices
+ * Computes the Laplacian matrix of a graph.
+ * Does NOT clear the matrix before writing.
+ * @template T Type of graph nodes.
+ * @param {Graph<T>} graph Input graph.
+ * @param {SquareMatrix} result Output: Laplacian matrix (modified in-place).
+ * @param {Map<T,number>} node_indices Map from graph nodes to matrix indices.
  */
 export function graph_compute_laplacian_matrix<T>(graph: Graph<T>, result: SquareMatrix, node_indices: Map<T, number>): void;
 import { SquareMatrix } from "../math/matrix/SquareMatrix.js";

package/src/core/graph/graph_compute_laplacian_matrix.js

@@ -4,12 +4,12 @@ import { graph_compute_adjacency_matrix } from "./graph_compute_adjacency_matrix
 import { graph_compute_degree_matrix } from "./graph_compute_degree_matrix.js";
 
 /**
- * Laplacian matrix (graph Laplacian)
- * NOTE: does not clear matrix before writing
- * @template T
- * @param {Graph<T>} graph
- * @param {SquareMatrix} result
- * @param {Map<T,number>} node_indices
+ * Computes the Laplacian matrix of a graph.
+ * Does NOT clear the matrix before writing.
+ * @template T Type of graph nodes.
+ * @param {Graph<T>} graph Input graph.
+ * @param {SquareMatrix} result Output: Laplacian matrix (modified in-place).
+ * @param {Map<T,number>} node_indices Map from graph nodes to matrix indices.
  */
 export function graph_compute_laplacian_matrix(graph, result, node_indices) {
     const degree = new SquareMatrix(result.size, BinaryDataType.Uint8);

package/src/core/json/abstractJSONDeserializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abstractJSONDeserializer.d.ts","sourceRoot":"","sources":["../../../../src/core/json/abstractJSONDeserializer.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,yCAJa,CAAC,QACH,CAAC,iBACD,GAAG,CAAC,MAAM,WAAW,OAqB/B"}
+{"version":3,"file":"abstractJSONDeserializer.d.ts","sourceRoot":"","sources":["../../../../src/core/json/abstractJSONDeserializer.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,yCAJa,CAAC,QACH,CAAC,iBACD,GAAG,CAAC,MAAM,WAAW,OA2B/B"}

package/src/core/json/abstractJSONDeserializer.js

@@ -21,5 +21,11 @@ export function abstractJSONDeserializer(json, deserializers) {
         throw new Error(`No deserializer found for type '${typeName}'`);
     }
 
-    return deserializer(json.data);
+    const payload = json.data;
+
+    if (payload === undefined) {
+        console.warn(`No serialized payload for type '${typeName}'`);
+    }
+
+    return deserializer(payload);
 }

package/src/core/math/bell_membership_function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bell_membership_function.d.ts","sourceRoot":"","sources":["../../../../src/core/math/bell_membership_function.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,4CANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CASlB"}
+{"version":3,"file":"bell_membership_function.d.ts","sourceRoot":"","sources":["../../../../src/core/math/bell_membership_function.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,4CANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAclB"}

package/src/core/math/bell_membership_function.js

@@ -10,8 +10,13 @@
  * @returns {number}
  */
 export function bell_membership_function(v, a, b, c) {
+    if(a === 0){
+        // avoid division by 0
+        return 0;
+    }
 
-    const N = (v - c) / a;
+    const vc = v - c;
+    const N = vc / a;
 
     const d = 1 + Math.pow(N, b * 2);
 

package/src/core/math/linalg/m2/m2_polar_decomp.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Performs a polar decomposition of a 2x2 matrix.
+ * This function decomposes a 2x2 matrix `m` into two matrices, `R` and `S`,
+ * such that m = S * R, where:
+ *  - R is a 2x2 orthogonal matrix (representing a rotation).
+ *  - S is a 2x2 symmetric positive semi-definite matrix.
+ * The input matrix `m` and output matrices `R` and `S` are stored in a flattened,
+ * transposed format (consistent with the Taichi programming language convention).
+ *
+ * @param {number[]} R Output: 2x2 orthogonal matrix (rotation), stored as a flattened
+ *  array [c, s, -s, c], where 'c' is the cosine and 's' is the sine of the rotation
+ *  angle. Modified in-place.
+ * @param {number[]} S Output: 2x2 symmetric positive semi-definite matrix,
+ *  stored as a flattened array. Modified in-place.
+ * @param {number[]} m Input: 2x2 matrix, stored as a flattened, *transposed* array [a, b, c, d],
+ * representing the matrix [[a, c], [b, d]]. Will be read from, but NOT modified.
+ */
+export function m2_polar_decomp(R: number[], S: number[], m: number[]): void;
+//# sourceMappingURL=m2_polar_decomp.d.ts.map

package/src/core/math/linalg/m2/m2_polar_decomp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m2_polar_decomp.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/m2/m2_polar_decomp.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,mCARW,MAAM,EAAE,KAGR,MAAM,EAAE,KAER,MAAM,EAAE,QASlB"}

package/src/core/math/linalg/m2/m2_polar_decomp.js

@@ -0,0 +1,27 @@
+import { m2_multiply } from "../../../geom/mat2/m2_multiply.js";
+import { m2_polar_decomp_noS } from "./m2_polar_decomp_noS.js";
+
+/**
+ * Performs a polar decomposition of a 2x2 matrix.
+ * This function decomposes a 2x2 matrix `m` into two matrices, `R` and `S`,
+ * such that m = S * R, where:
+ *  - R is a 2x2 orthogonal matrix (representing a rotation).
+ *  - S is a 2x2 symmetric positive semi-definite matrix.
+ * The input matrix `m` and output matrices `R` and `S` are stored in a flattened,
+ * transposed format (consistent with the Taichi programming language convention).
+ *
+ * @param {number[]} R Output: 2x2 orthogonal matrix (rotation), stored as a flattened
+ *  array [c, s, -s, c], where 'c' is the cosine and 's' is the sine of the rotation
+ *  angle. Modified in-place.
+ * @param {number[]} S Output: 2x2 symmetric positive semi-definite matrix,
+ *  stored as a flattened array. Modified in-place.
+ * @param {number[]} m Input: 2x2 matrix, stored as a flattened, *transposed* array [a, b, c, d],
+ * representing the matrix [[a, c], [b, d]]. Will be read from, but NOT modified.
+ */
+export function m2_polar_decomp(R, S, m) {
+    // transposed as in taichi
+
+    m2_polar_decomp_noS(R, m);
+
+    m2_multiply(S, m, R);
+}

package/src/core/math/linalg/m2/m2_polar_decomp_noS.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Performs a polar decomposition of a 2x2 matrix, returning only the rotation matrix (R).
+ * This function is optimized for speed and assumes the input matrix `m` is stored in a flattened,
+ * transposed format (consistent with the Taichi programming language convention).
+ * It decomposes `m` into R, such that m = R * S, where R is a 2x2 rotation matrix.
+ * The symmetric matrix S is *not* computed. This version is optimized
+ * for cases where only the rotational component (R) is needed.
+ *
+ * @param {number[]} R Output: 2x2 rotation matrix, stored as a flattened array [c, s, -s, c],
+ *  where 'c' is the cosine and 's' is the sine of the rotation angle.  Modified in-place.
+ * @param {number[]} m Input: 2x2 matrix, stored as a flattened, *transposed* array [a, b, c, d],
+ *  representing the matrix [[a, c], [b, d]].
+ */
+export function m2_polar_decomp_noS(R: number[], m: number[]): void;
+//# sourceMappingURL=m2_polar_decomp_noS.d.ts.map

package/src/core/math/linalg/m2/m2_polar_decomp_noS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m2_polar_decomp_noS.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/m2/m2_polar_decomp_noS.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,uCALW,MAAM,EAAE,KAER,MAAM,EAAE,QAqBlB"}

package/src/core/math/linalg/m2/m2_polar_decomp_noS.js

@@ -0,0 +1,32 @@
+/**
+ * Performs a polar decomposition of a 2x2 matrix, returning only the rotation matrix (R).
+ * This function is optimized for speed and assumes the input matrix `m` is stored in a flattened,
+ * transposed format (consistent with the Taichi programming language convention).
+ * It decomposes `m` into R, such that m = R * S, where R is a 2x2 rotation matrix.
+ * The symmetric matrix S is *not* computed. This version is optimized
+ * for cases where only the rotational component (R) is needed.
+ *
+ * @param {number[]} R Output: 2x2 rotation matrix, stored as a flattened array [c, s, -s, c],
+ *  where 'c' is the cosine and 's' is the sine of the rotation angle.  Modified in-place.
+ * @param {number[]} m Input: 2x2 matrix, stored as a flattened, *transposed* array [a, b, c, d],
+ *  representing the matrix [[a, c], [b, d]].
+ */
+export function m2_polar_decomp_noS(
+    R,
+    m
+) {
+    // transposed as in taichi
+    const x = m[0] + m[3];
+    const y = m[2] - m[1];
+
+    const scale = 1.0 / Math.sqrt(x * x + y * y);
+
+    const c = x * scale;
+    const s = y * scale;
+
+    R[0] = c;
+    R[1] = s;
+    R[2] = -s;
+    R[3] = c;
+
+}

package/src/core/math/linalg/m2/m2_svd.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Performs Singular Value Decomposition (SVD) on a 2x2 matrix, optimized for MLS-MPM.
+ *
+ * This function computes the SVD of a 2x2 matrix `m` such that m = U * Σ * V^T, where:
+ *
+ * - U is a 2x2 orthogonal matrix (rotation).
+ * - Σ (sig) is a 2x2 diagonal matrix containing the singular values.
+ * - V is a 2x2 orthogonal matrix (rotation).
+ *
+ * The function modifies U, sig, and V in-place. The input matrix `m` and the intermediate matrix `S` are overwritten during the computation.
+ * The algorithm uses a closed-form solution and optimizations specific to 2x2 matrices, making it very fast. It also handles the case where the off-diagonal elements of the intermediate matrix S are close to zero, simplifying calculations.  The results are transposed, consistent with the Taichi programming language.
+ * @param {number[]} U Output: 2x2 orthogonal matrix (rotation), stored as a flattened array [c, s, -s, c]. Modified in-place.
+ * @param {number[]} S Output: Intermediate 2x2 matrix, overwritten during calculation. Modified in-place.
+ * @param {number[]} V Output: 2x2 orthogonal matrix (rotation), stored as a flattened array. Modified in-place.
+ * @param {number[]} sig Output: 2x2 diagonal matrix containing singular values, stored as a flattened array [σ1, 0, 0, σ2]. Modified in-place.
+ * @param {number[]} m Input: 2x2 matrix, stored as a flattened array [a, b, c, d], representing [[a, c], [b, d]].  Will be overwritten.
+ */
+export function m2_svd(U: number[], S: number[], V: number[], sig: number[], m: number[]): void;
+//# sourceMappingURL=m2_svd.d.ts.map

package/src/core/math/linalg/m2/m2_svd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m2_svd.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/m2/m2_svd.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,0BANW,MAAM,EAAE,KACR,MAAM,EAAE,KACR,MAAM,EAAE,OACR,MAAM,EAAE,KACR,MAAM,EAAE,QA6ElB"}

package/src/core/math/linalg/m2/m2_svd.js

@@ -0,0 +1,96 @@
+import { m2_multiply } from "../../../geom/mat2/m2_multiply.js";
+import { m2_polar_decomp } from "./m2_polar_decomp.js";
+
+/**
+ * Performs Singular Value Decomposition (SVD) on a 2x2 matrix, optimized for MLS-MPM.
+ *
+ * This function computes the SVD of a 2x2 matrix `m` such that m = U * Σ * V^T, where:
+ *
+ * - U is a 2x2 orthogonal matrix (rotation).
+ * - Σ (sig) is a 2x2 diagonal matrix containing the singular values.
+ * - V is a 2x2 orthogonal matrix (rotation).
+ *
+ * The function modifies U, sig, and V in-place. The input matrix `m` and the intermediate matrix `S` are overwritten during the computation.
+ * The algorithm uses a closed-form solution and optimizations specific to 2x2 matrices, making it very fast. It also handles the case where the off-diagonal elements of the intermediate matrix S are close to zero, simplifying calculations.  The results are transposed, consistent with the Taichi programming language.
+ * @param {number[]} U Output: 2x2 orthogonal matrix (rotation), stored as a flattened array [c, s, -s, c]. Modified in-place.
+ * @param {number[]} S Output: Intermediate 2x2 matrix, overwritten during calculation. Modified in-place.
+ * @param {number[]} V Output: 2x2 orthogonal matrix (rotation), stored as a flattened array. Modified in-place.
+ * @param {number[]} sig Output: 2x2 diagonal matrix containing singular values, stored as a flattened array [σ1, 0, 0, σ2]. Modified in-place.
+ * @param {number[]} m Input: 2x2 matrix, stored as a flattened array [a, b, c, d], representing [[a, c], [b, d]].  Will be overwritten.
+ */
+export function m2_svd(
+    U,
+    S,
+    V,
+    sig,
+    m
+) {
+    // transposed as in taichi
+
+    m2_polar_decomp(U, S, m);
+
+    let c, s;
+
+    if (Math.abs(S[1]) < 1e-6) {
+        // If the off-diagonal element of S is close to zero,
+        // S is already diagonal. No rotation needed for V.
+
+        sig[0] = S[0];
+        sig[1] = 0; // Ensure off-diagonal is exactly zero
+        sig[2] = 0; // Ensure off-diagonal is exactly zero
+        sig[3] = S[3];
+
+        c = 1;
+        s = 0;
+
+    } else {
+        const tao = 0.5 * (S[0] - S[3]);
+
+        const w = Math.sqrt(tao * tao + S[1] * S[1]);
+
+        // Numerical Methods for Engineers, Chapra, Canale, 6th Ed., p. 292
+        const t = tao > 0 ? S[1] / (tao + w) : S[1] / (tao - w);
+
+        c = 1.0 / Math.sqrt(t * t + 1);
+
+        s = -t * c;
+
+        const s2 = s * s;
+        const c2 = c * c;
+
+        const cs_2 = 2 * c * s;
+
+        sig[0] = c2 * S[0] - cs_2 * S[1] + s2 * S[3];
+        sig[1] = 0;
+        sig[2] = 0;
+        sig[3] = s2 * S[0] + cs_2 * S[1] + c2 * S[3];
+    }
+
+    if (sig[0] < sig[3]) {
+
+        // Swap singular values if they are not in descending order.
+        const tmp = sig[0];
+
+        sig[0] = sig[3];
+        sig[3] = tmp;
+
+        // Correspondingly swap columns of V (remember, V is transposed here).
+
+        V[0] = -s;
+        V[1] = c;
+        V[2] = -c;
+        V[3] = -s;
+
+    } else {
+
+        // If already in descending order
+
+        V[0] = c;
+        V[1] = s;
+        V[2] = -s;
+        V[3] = c;
+
+    }
+
+    m2_multiply(U, U, V);
+}

package/src/core/math/linalg/solve_linear_system_GEPP_2x2.d.ts

@@ -4,7 +4,7 @@
  * @param {number[]} A
  * @param {number[]} x
  * @param {number[]} b
- * @returns {boolean}
+ * @returns {boolean} `true` iff solution is found, false otherwise
  */
 export function solve_linear_system_GEPP_2x2(A: number[], x: number[], b: number[]): boolean;
 //# sourceMappingURL=solve_linear_system_GEPP_2x2.d.ts.map

package/src/core/math/linalg/solve_linear_system_GEPP_2x2.js

@@ -11,7 +11,7 @@ const epsilon = 256 * FLT_EPSILON_64;
  * @param {number[]} A
  * @param {number[]} x
  * @param {number[]} b
- * @returns {boolean}
+ * @returns {boolean} `true` iff solution is found, false otherwise
  */
 export function solve_linear_system_GEPP_2x2(A, x, b) {
 

package/src/core/model/node-graph/node/NodeDescription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/node/NodeDescription.js"],"names":[],"mappings":"AAwCA;IACI;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,IAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,iBAFU,IAAI,EAAE,CAEL;IAEX;;;OAGG;IACH,YAFU,wBAAwB,EAAE,CAEpB;IAEhB;;OAEG;IACH;QACI;;;WAGG;4BADO,MAAM,CAAC,IAAI,CAAC;QAGtB;;;WAGG;8BADO,MAAM,CAAC,IAAI,CAAC;MAGxB;IAEF;;;;OAIG;IACH,wBAFW,YAAY,QAItB;IAED;;;OAGG;IACH,gBAFa,IAAI,EAAE,CAIlB;IAED;;;OAGG;IACH,eAFa,IAAI,EAAE,CAIlB;IAED;;;;;;OAMG;IACH,sBALW,MAAM,QACN,qBAAqB,iBACrB,MAAM,GAAC,OAAO,GAAC,MAAM,GACnB,MAAM,CA0ClB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,wBAAwB,GAAC,IAAI,CAiBzC;IAGD;;;;;;OAMG;IACH,iBALW,QAAQ,2BAER,aAAa,GACX,MAAM,CA2BlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAuBnB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAgBrB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,EAAE,CAwBjB;IAED;;;;;OAKG;IACH,+BAHW,aAAa,GACZ,OAAO,CAiBlB;IAED;;;;OAIG;IACH,+BAHW,aAAa,GACZ,IAAI,EAAE,CAuBjB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,aACN,aAAa,GACZ,IAAI,GAAC,SAAS,CAmBzB;IAED;;;OAGG;IACH,YAFa,IAAI,EAAE,CAIlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAYnB;IAED,mBAEC;IAED;;;;MAMC;IAED;;;;;;OAMG;IACH,8BALW,EAAE,YAGF,YAAY,QAUtB;IAKL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAR1C;;;;qBAvaoB,WAAW;yCADS,yCAAyC;mBAH/D,kCAAkC;sCAEf,sCAAsC;8BAG9C,oBAAoB"}
+{"version":3,"file":"NodeDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/node/NodeDescription.js"],"names":[],"mappings":"AAwCA;IAsXI;;;;;OAKG;IACH,kCAHW,YAAY,GACV,eAAe,CAQ3B;IAjYD;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,IAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,iBAFU,IAAI,EAAE,CAEL;IAEX;;;OAGG;IACH,YAFU,wBAAwB,EAAE,CAEpB;IAEhB;;OAEG;IACH;QACI;;;WAGG;4BADO,MAAM,CAAC,IAAI,CAAC;QAGtB;;;WAGG;8BADO,MAAM,CAAC,IAAI,CAAC;MAGxB;IAEF;;;;OAIG;IACH,wBAFW,YAAY,QAItB;IAED;;;OAGG;IACH,gBAFa,IAAI,EAAE,CAIlB;IAED;;;OAGG;IACH,eAFa,IAAI,EAAE,CAIlB;IAED;;;;;;OAMG;IACH,sBALW,MAAM,QACN,qBAAqB,iBACrB,MAAM,GAAC,OAAO,GAAC,MAAM,GACnB,MAAM,CA0ClB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,wBAAwB,GAAC,IAAI,CAiBzC;IAGD;;;;;;OAMG;IACH,iBALW,QAAQ,2BAER,aAAa,GACX,MAAM,CA2BlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAuBnB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAgBrB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,EAAE,CAwBjB;IAED;;;;;OAKG;IACH,+BAHW,aAAa,GACZ,OAAO,CAiBlB;IAED;;;;OAIG;IACH,+BAHW,aAAa,GACZ,IAAI,EAAE,CAuBjB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,aACN,aAAa,GACZ,IAAI,GAAC,SAAS,CAmBzB;IAED;;;OAGG;IACH,YAFa,IAAI,EAAE,CAIlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAYnB;IAED,mBAEC;IAED;;;;MAMC;IAgBD;;;;;;OAMG;IACH,8BALW,EAAE,YAGF,YAAY,QAUtB;IAKL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAR1C;;;;qBArboB,WAAW;yCADS,yCAAyC;mBAH/D,kCAAkC;sCAEf,sCAAsC;8BAG9C,oBAAoB"}

package/src/core/model/node-graph/node/NodeDescription.js

@@ -412,6 +412,20 @@ export class NodeDescription {
         }
     }
 
+    /**
+     *
+     * @param j
+     * @param {NodeRegistry} registry
+     * @returns {NodeDescription}
+     */
+    static fromJSON(j, registry){
+        const r = new NodeDescription();
+
+        r.fromJSON(j,registry);
+
+        return r;
+    }
+
     /**
      *
      * @param {[]} ports

package/src/core/model/node-graph/type/DataType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataType.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/type/DataType.js"],"names":[],"mappings":"AAEA;IAyDI;;;;OAIG;IACH,mBAHW,GAAC,GACC,QAAQ,CAQpB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,QAAQ,CAQpB;IAjFD;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,mBAEC;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAKnB;IAED;;;;OAIG;IACH,QAHW,MAAM,QACN,MAAM,QAQhB;IAED;;;MAEC;IAED;;;aAEC;IAgCL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B"}
+{"version":3,"file":"DataType.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/type/DataType.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAyDI;;;;OAIG;IACH,mBAHW,GAAC,GACC,QAAQ,CAQpB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,QAAQ,CAQpB;IAjFD;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,mBAEC;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAKnB;IAED;;;;OAIG;IACH,QAHW,MAAM,QACN,MAAM,QAQhB;IAED;;;MAEC;IAED;;;aAEC;IAgCL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B"}

package/src/core/model/node-graph/type/DataType.js

@@ -1,5 +1,9 @@
 import { assert } from "../../../assert.js";
 
+/**
+ * Abstract type representation.
+ * Useful for tagging data
+ */
 export class DataType {
 
     /**