@woosh/meep-engine 2.106.1 → 2.108.0

package/src/core/geom/mat3/m3_multiply_vec3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m3_multiply_vec3.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/mat3/m3_multiply_vec3.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oEAcC"}

package/src/core/geom/mat3/m3_multiply_vec3.js

@@ -0,0 +1,21 @@
+/**
+ *
+ * @param {mat3} out
+ * @param {mat3} a
+ * @param {vec3} v
+ */
+export function m3_multiply_vec3(out, a, v) {
+    const x = v[0];
+    const y = v[1];
+    const z = v[2];
+
+    out[0] = x * a[0];
+    out[1] = x * a[1];
+    out[2] = x * a[2];
+    out[3] = y * a[3];
+    out[4] = y * a[4];
+    out[5] = y * a[5];
+    out[6] = z * a[6];
+    out[7] = z * a[7];
+    out[8] = z * a[8];
+}

package/src/core/geom/vec2/v2_cross_product.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Not really a cross-product, since that doesn't exist in 2d.
+ * We imagine Z to be 0, and essentially do a 3d vector cross product
+ * Also known as "perpendicular dot product"
+ * Also known as "exterior product"
+ * Also known as "determinant"
+ * Also known as "wedge product"
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @return {number}
+ */
+export function v2_cross_product(x0: number, y0: number, x1: number, y1: number): number;
+//# sourceMappingURL=v2_cross_product.d.ts.map

package/src/core/geom/vec2/v2_cross_product.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v2_cross_product.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec2/v2_cross_product.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,qCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CASjB"}

package/src/core/geom/vec2/v2_cross_product.js

@@ -0,0 +1,21 @@
+/**
+ * Not really a cross-product, since that doesn't exist in 2d.
+ * We imagine Z to be 0, and essentially do a 3d vector cross product
+ * Also known as "perpendicular dot product"
+ * Also known as "exterior product"
+ * Also known as "determinant"
+ * Also known as "wedge product"
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @return {number}
+ */
+export function v2_cross_product(
+    x0, y0,
+    x1, y1
+) {
+
+    return x0 * y1 - y0 * x1;
+
+}

package/src/core/geom/vec3/v3_slerp.d.ts

@@ -1,5 +1,6 @@
 /**
  * Spherical linear interpolation
+ * NOTE: vectors are assumed to be normalized
  * @see https://en.wikipedia.org/wiki/Slerp
  * @param {Vector3} result
  * @param {number} a_x

package/src/core/geom/vec3/v3_slerp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_slerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_slerp.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,+CARW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,YACN,MAAM,QAkChB"}
+{"version":3,"file":"v3_slerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_slerp.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,+CARW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,YACN,MAAM,QAkChB"}

package/src/core/geom/vec3/v3_slerp.js

@@ -3,6 +3,7 @@ import { v3_lerp } from "./v3_lerp.js";
 
 /**
  * Spherical linear interpolation
+ * NOTE: vectors are assumed to be normalized
  * @see https://en.wikipedia.org/wiki/Slerp
  * @param {Vector3} result
  * @param {number} a_x

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

@@ -1 +1 @@
-{"version":3,"file":"Edge.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/Edge.js"],"names":[],"mappings":"gCASU,MAAM;;;;;;AAQhB;;GAEG;AACH;IACI;;;;;OAKG;IACH,4BAmBC;IAfG;;;OAGG;IACH,WAAc;IACd;;;OAGG;IACH,YAAe;IAEf;;OAEG;IACH,WAFU,iBAAiB,CAEkB;IAGjD;;;;OAIG;IACH,eAHW,CAAC,GACA,OAAO,CAIlB;IAED;;;;;OAKG;IACH,2BAJW,CAAC,UACD,CAAC,GACC,OAAO,CASnB;IAED;;;;OAIG;IACH,YAHW,CAAC,GACC,CAAC,CAIb;IAED;;;OAGG;IACH,sBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,wBAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,iBAEC;IAIL;;;OAGG;IACH,QAFU,OAAO,CAEI;CANpB"}
+{"version":3,"file":"Edge.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/Edge.js"],"names":[],"mappings":"gCAIU,MAAM;;;;;;AAQhB;;GAEG;AACH;IACI;;;;;OAKG;IACH,4BAmBC;IAfG;;;OAGG;IACH,WAAc;IACd;;;OAGG;IACH,YAAe;IAEf;;OAEG;IACH,WAFU,iBAAiB,CAEkB;IAGjD;;;;OAIG;IACH,eAHW,CAAC,GACA,OAAO,CAIlB;IAED;;;;;OAKG;IACH,2BAJW,CAAC,UACD,CAAC,GACC,OAAO,CASnB;IAED;;;;OAIG;IACH,YAHW,CAAC,GACC,CAAC,CAIb;IAED;;;OAGG;IACH,sBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,wBAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,iBAEC;IAIL;;;OAGG;IACH,QAFU,OAAO,CAEI;CANpB"}

package/src/core/graph/Edge.js

@@ -1,8 +1,3 @@
-/**
- * Created by Alex on 29/01/14.
- */
-
-
 import { assert } from "../assert.js";
 
 /**

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

@@ -15,7 +15,7 @@ export class MultiNode<T> {
      */
     source_nodes: T[];
     /**
-     *
+     * Absorb nodes from another node
      * @param {MultiNode<T>} other
      */
     add(other: MultiNode<T>): void;

package/src/core/graph/MultiNode.js

@@ -10,7 +10,7 @@ export class MultiNode {
     source_nodes = [];
 
     /**
-     *
+     * Absorb nodes from another node
      * @param {MultiNode<T>} other
      */
     add(other) {

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

@@ -1,17 +1,19 @@
-export class WeightedEdge extends Edge<any> {
+/**
+ * @template T
+ */
+export class WeightedEdge<T> extends Edge<any> {
     /**
      *
      * @param {WeightedEdge} e
      * @returns {number}
      */
-    static extractWeight(e: WeightedEdge): number;
+    static extractWeight(e: WeightedEdge<any>): number;
     /**
      *
      * @param {WeightedEdge} e
      * @returns {number}
      */
-    static extractNegativeWeight(e: WeightedEdge): number;
-    constructor(a: N, b: N);
+    static extractNegativeWeight(e: WeightedEdge<any>): number;
     /**
      *
      * @type {number}

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

@@ -1 +1 @@
-{"version":3,"file":"WeightedEdge.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/WeightedEdge.js"],"names":[],"mappings":"AAEA;IAOI;;;;OAIG;IACH,wBAHW,YAAY,GACV,MAAM,CAIlB;IAED;;;;OAIG;IACH,gCAHW,YAAY,GACV,MAAM,CAIlB;IAVG,wBAYoS;IAxBxS;;;OAGG;IACH,QAFU,MAAM,CAEL;CAmBd;qBA1BoB,WAAW"}
+{"version":3,"file":"WeightedEdge.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/WeightedEdge.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAOI;;;;OAIG;IACH,4CAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,oDAFa,MAAM,CAIlB;IAtBD;;;OAGG;IACH,QAFU,MAAM,CAEL;CAmBd;qBA7BoB,WAAW"}

package/src/core/graph/WeightedEdge.js

@@ -1,5 +1,8 @@
 import { Edge } from "./Edge.js";
 
+/**
+ * @template T
+ */
 export class WeightedEdge extends Edge {
     /**
      *

package/src/core/graph/coloring/colorizeGraph.js

@@ -97,7 +97,7 @@ function updateNN(NN, a, vertexCount, colors, colorNumber) {
 
             const columnAddress = i * vertexCount;
 
-            for (var j = 0; j < NN.length; j++) {
+            for (let j = 0; j < NN.length; j++) {
 
 
                 while (a[columnAddress + NN[j]] === 1) {
@@ -121,25 +121,25 @@ function updateNN(NN, a, vertexCount, colors, colorNumber) {
  * @return {number[]}
  */
 function findSuitableY(vertexCount, a, NN, color, colorNumber) {
-    var temp, tmp_y, y = 0;
+    let temp, tmp_y, y = 0;
 
-    var scanned = [];
+    const scanned = [];
 
     let VerticesInCommon = 0;
 
-    for (var i = 0; i < NN.length; i++) {
+    for (let i = 0; i < NN.length; i++) {
         tmp_y = NN[i];
         temp = 0;
 
-        for (var f = 0; f < vertexCount; f++) {
+        for (let f = 0; f < vertexCount; f++) {
             scanned[f] = 0;
         }
 
-        for (var x = 0; x < vertexCount; x++) {
+        for (let x = 0; x < vertexCount; x++) {
 
             if (color[x] === colorNumber) {
 
-                for (var k = 0; k < vertexCount; k++) {
+                for (let k = 0; k < vertexCount; k++) {
 
                     if (color[k] === 0 && scanned[k] === 0) {
 
@@ -174,12 +174,12 @@ function findSuitableY(vertexCount, a, NN, color, colorNumber) {
  */
 function computeMaxDegreeInNN(NN, colors, degree) {
 
-    var max = -1;
-    var max_i, i;
+    let max = -1;
+    let max_i, i;
 
     const l = NN.length;
 
-    for (var k = 0; k < l; k++) {
+    for (let k = 0; k < l; k++) {
         i = NN[k];
 
         if ((colors[i] === 0) && (degree[i] > max)) {
@@ -201,15 +201,15 @@ function computeMaxDegreeInNN(NN, colors, degree) {
 function colorizing(a, vertexCount) {
     const NN = [];
 
-    var colors = [];
-    var degrees = [];
+    const colors = [];
+    const degrees = [];
 
-    for (var i = 0; i < vertexCount; i++) {
+    for (let i = 0; i < vertexCount; i++) {
 
         colors[i] = 0;
         degrees[i] = 0;
 
-        for (var j = 0; j < vertexCount; j++) {
+        for (let j = 0; j < vertexCount; j++) {
             const address = i * vertexCount + j;
 
             if (a[address] === 1) {
@@ -220,11 +220,11 @@ function colorizing(a, vertexCount) {
 
     }
 
-    var x, y;
-    var result;
-    var colorNumber = 0;
-    var VerticesInCommon = 0;
-    var unprocessed = vertexCount;
+    let x, y;
+    let result;
+    let colorNumber = 0;
+    let VerticesInCommon = 0;
+    let unprocessed = vertexCount;
 
     while (unprocessed > 0) {
         x = computeMaxDegreeVertex(vertexCount, colors, degrees);

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

@@ -1,6 +1,6 @@
 /**
- * @template Node
  * Build a Graphviz DOT representation of the graph
+ * @template Node
  * @param {Graph<Node>} graph
  * @param {function(Node):string} nodeToDot
  * @returns {string}

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

@@ -1 +1 @@
-{"version":3,"file":"convert_graph_to_dot_string.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/convert_graph_to_dot_string.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,0FAFa,MAAM,CAgElB"}
+{"version":3,"file":"convert_graph_to_dot_string.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/convert_graph_to_dot_string.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,0FAFa,MAAM,CAgElB"}

package/src/core/graph/convert_graph_to_dot_string.js

@@ -1,22 +1,26 @@
 import LineBuilder from "../codegen/LineBuilder.js";
 import { EdgeDirectionType } from "./Edge.js";
 
-
-function defaultNodeToDot(node){
+/**
+ * @template T
+ * @param {T} node
+ * @return {string}
+ */
+function defaultNodeToDot(node) {
     return `[label="${node.toString()}"]`;
 }
 
 /**
- * @template Node
  * Build a Graphviz DOT representation of the graph
+ * @template Node
  * @param {Graph<Node>} graph
  * @param {function(Node):string} nodeToDot
  * @returns {string}
  */
 export function convert_graph_to_dot_string({
-                                            graph,
-                                            nodeToDot=defaultNodeToDot
-}) {
+                                                graph,
+                                                nodeToDot = defaultNodeToDot
+                                            }) {
     const lb = new LineBuilder();
 
     lb.add('strict digraph Graph {');

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

@@ -0,0 +1,9 @@
+/**
+ * NOTE: does not clear matrix before writing adjacency
+ * @template T
+ * @param {Graph<T>} graph
+ * @param {SquareMatrix} result
+ * @param {Map<T,number>} node_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

@@ -0,0 +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,6HAUC"}

package/src/core/graph/{graph_adjacency_matrix.js → graph_compute_adjacency_matrix.js}

@@ -1,4 +1,3 @@
-//
 
 
 /**
@@ -8,7 +7,7 @@
  * @param {SquareMatrix} result
  * @param {Map<T,number>} node_indices
  */
-export function graph_adjacency_matrix(graph, result, node_indices) {
+export function graph_compute_adjacency_matrix(graph, result, node_indices) {
     const edges = graph.getEdges();
 
     for (const edge of edges) {

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

@@ -0,0 +1,10 @@
+/**
+ * Builds a matrix with node cardinality for each Node, that is, number of edges attached to each Node
+ * NOTE: does not clear matrix before writing
+ * @template T
+ * @param {Graph<T>} graph
+ * @param {SquareMatrix} result Where to store the result
+ * @param {Map<T,number>} node_indices de-referencing dictionary from Node to unsigned integer index
+ */
+export function graph_compute_degree_matrix<T>(graph: Graph<T>, result: SquareMatrix, node_indices: Map<T, number>): void;
+//# sourceMappingURL=graph_compute_degree_matrix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_compute_degree_matrix.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/graph_compute_degree_matrix.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,0HAYC"}

package/src/core/graph/graph_compute_degree_matrix.js

@@ -0,0 +1,23 @@
+import { assert } from "../assert.js";
+
+/**
+ * Builds a matrix with node cardinality for each Node, that is, number of edges attached to each Node
+ * NOTE: does not clear matrix before writing
+ * @template T
+ * @param {Graph<T>} graph
+ * @param {SquareMatrix} result Where to store the result
+ * @param {Map<T,number>} node_indices de-referencing dictionary from Node to unsigned integer index
+ */
+export function graph_compute_degree_matrix(graph, result, node_indices) {
+    const nodes = graph.getNodes();
+
+    for (const node of nodes) {
+        const node_index = node_indices.get(node);
+
+        assert.isNonNegativeInteger(node_index, 'index');
+
+        const degree = graph.getNodeDegree(node);
+
+        result.setCellValue(node_index, node_index, degree);
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Produce a distance matrix from an input graph, tracing distances from each node to every node specified in target vector
+ * @see "A Fast Algorithm to Find All-Pairs Shortest Paths in Complex Networks" by Wei Peng et Al. 2012
+ * @template T
+ * @param {Graph<T>} graph
+ * @param {T[]} node_array graph nodes as an array
+ * @param {number[]} targets node indices, distances to which need to be calculated
+ * @param {Map<T, number>} node_index_map
+ * @returns {SquareMatrix}
+ */
+export function graph_compute_distance_matrix<T>(graph: Graph<T>, node_array: T[], targets: number[], node_index_map: Map<T, number>): SquareMatrix;
+import { SquareMatrix } from "./SquareMatrix.js";
+//# sourceMappingURL=graph_compute_distance_matrix.d.ts.map

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

@@ -0,0 +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,4FAJW,MAAM,EAAE,mCAEN,YAAY,CAyFxB;6BAnG4B,mBAAmB"}

package/src/core/graph/graph_compute_distance_matrix.js

@@ -0,0 +1,103 @@
+import { BitSet } from "../binary/BitSet.js";
+import { BinaryDataType } from "../binary/type/BinaryDataType.js";
+import FastBinaryHeap from "../collection/heap/FastBinaryHeap.js";
+import { SquareMatrix } from "./SquareMatrix.js";
+
+/**
+ * Produce a distance matrix from an input graph, tracing distances from each node to every node specified in target vector
+ * @see "A Fast Algorithm to Find All-Pairs Shortest Paths in Complex Networks" by Wei Peng et Al. 2012
+ * @template T
+ * @param {Graph<T>} graph
+ * @param {T[]} node_array graph nodes as an array
+ * @param {number[]} targets node indices, distances to which need to be calculated
+ * @param {Map<T, number>} node_index_map
+ * @returns {SquareMatrix}
+ */
+export function graph_compute_distance_matrix(graph, node_array, targets, node_index_map) {
+    const node_count = node_array.length;
+
+    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;
+
+    /**
+     *
+     * @param {number} other_node
+     * @returns {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 heap = new FastBinaryHeap(score);
+        heap.push(source_node);
+
+        while (!heap.isEmpty()) {
+            const t = heap.pop();
+
+            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);
+
+                    if (shortcut_distance < m_distances.getCellValue(source_node, v)) {
+                        m_distances.setCellValue(source_node, v, shortcut_distance)
+                    }
+
+                }
+            } else {
+                // not visited yet
+                const t_node = node_array[t];
+
+                const t_node_container = graph.getNodeContainer(t_node);
+
+                const node_edges = t_node_container.getEdges();
+                const node_edge_count = node_edges.length;
+
+                for (let i1 = 0; i1 < node_edge_count; i1++) {
+
+                    /**
+                     *
+                     * @type {WeightedEdge<N>}
+                     */
+                    const node_edge = node_edges[i1];
+
+                    const neighbour_node = node_edge.other(t_node);
+
+                    const neighbour_node_index = node_index_map.get(neighbour_node);
+
+                    if (neighbour_node_index === -1) {
+                        // not in the input set
+                        continue;
+                    }
+
+                    const transition_cost = node_edge.weight + 1e-5;
+
+                    const distance_to_neighbour = distance_to_this_node + 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);
+
+                        heap.push(neighbour_node_index);
+                    }
+                }
+            }
+        }
+
+        flags.set(source_node, true);
+    }
+
+    return m_distances;
+}

package/src/core/graph/{graph_laplacian_matrix.d.ts → graph_compute_laplacian_matrix.d.ts}

@@ -6,6 +6,6 @@
  * @param {SquareMatrix} result
  * @param {Map<T,number>} node_indices
  */
-export function graph_laplacian_matrix<T>(graph: Graph<T>, result: SquareMatrix, node_indices: Map<T, number>): void;
+export function graph_compute_laplacian_matrix<T>(graph: Graph<T>, result: SquareMatrix, node_indices: Map<T, number>): void;
 import { SquareMatrix } from "./SquareMatrix.js";
-//# sourceMappingURL=graph_laplacian_matrix.d.ts.map
+//# sourceMappingURL=graph_compute_laplacian_matrix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_compute_laplacian_matrix.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/graph_compute_laplacian_matrix.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,2EAHW,YAAY,sCAWtB;6BAlB4B,mBAAmB"}

package/src/core/graph/{graph_laplacian_matrix.js → graph_compute_laplacian_matrix.js}

@@ -1,7 +1,7 @@
-import { graph_degree_matrix } from "./graph_degree_matrix.js";
-import { SquareMatrix } from "./SquareMatrix.js";
 import { BinaryDataType } from "../binary/type/BinaryDataType.js";
-import { graph_adjacency_matrix } from "./graph_adjacency_matrix.js";
+import { graph_compute_adjacency_matrix } from "./graph_compute_adjacency_matrix.js";
+import { graph_compute_degree_matrix } from "./graph_compute_degree_matrix.js";
+import { SquareMatrix } from "./SquareMatrix.js";
 
 /**
  * Laplacian matrix (graph Laplacian)
@@ -11,12 +11,12 @@ import { graph_adjacency_matrix } from "./graph_adjacency_matrix.js";
  * @param {SquareMatrix} result
  * @param {Map<T,number>} node_indices
  */
-export function graph_laplacian_matrix(graph, result, node_indices) {
+export function graph_compute_laplacian_matrix(graph, result, node_indices) {
     const degree = new SquareMatrix(result.size, BinaryDataType.Uint8);
     const adjacency = new SquareMatrix(result.size, BinaryDataType.Uint8);
 
-    graph_degree_matrix(graph, degree, node_indices);
-    graph_adjacency_matrix(graph, adjacency, node_indices);
+    graph_compute_degree_matrix(graph, degree, node_indices);
+    graph_compute_adjacency_matrix(graph, adjacency, node_indices);
 
     result.subtractMatrices(degree, adjacency);
 }

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

@@ -1 +1 @@
-{"version":3,"file":"graph_k_means_cluster.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/graph_k_means_cluster.js"],"names":[],"mappings":"AAyHA;;;;;;;;GAQG;AACH,2DARW,cAAc,KACd,MAAM,eACN,MAAM,4BACN,MAAM,EAAE,GAAC,UAAU,GAAC,WAAW,GAAC,WAAW,kBAC3C,OAAO,MAAM,CAAC,+BAEZ,MAAM,EAAE,EAAE,CA2EtB;AAED;;;;;;;GAOG;AACH,6DAJW,MAAM,eACN,MAAM,GACJ,MAAM,EAAE,EAAE,CA0BtB"}
+{"version":3,"file":"graph_k_means_cluster.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/graph_k_means_cluster.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,2DARW,cAAc,KACd,MAAM,eACN,MAAM,4BACN,MAAM,EAAE,GAAC,UAAU,GAAC,WAAW,GAAC,WAAW,kBAC3C,OAAO,MAAM,CAAC,+BAEZ,MAAM,EAAE,EAAE,CA2EtB;AAED;;;;;;;GAOG;AACH,6DAJW,MAAM,eACN,MAAM,GACJ,MAAM,EAAE,EAAE,CA0BtB"}