@woosh/meep-engine 2.107.0 → 2.108.2

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"}

package/src/core/graph/graph_k_means_cluster.js

@@ -1,122 +1,7 @@
 //
-import { seededRandom } from "../math/random/seededRandom.js";
-import { SquareMatrix } from "./SquareMatrix.js";
-import { BinaryDataType } from "../binary/type/BinaryDataType.js";
-import { BitSet } from "../binary/BitSet.js";
-import FastBinaryHeap from "../collection/heap/FastBinaryHeap.js";
 import { randomIntegerBetween } from "../math/random/randomIntegerBetween.js";
-
-/**
- * @template N
- * @param {N} n0
- * @param {N} n1
- * @param {Graph<N>} graph
- * @returns {number}
- */
-function node_distance(n0, n1, graph) {
-    const path = graph.findPath(n0, n1);
-
-    if (path === null) {
-        return Number.POSITIVE_INFINITY;
-    }
-
-    return path.length;
-}
-
-/**
- * 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}
- */
-function build_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++) {
-
-                    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;
-}
+import { seededRandom } from "../math/random/seededRandom.js";
+import { graph_compute_distance_matrix } from "./graph_compute_distance_matrix.js";
 
 
 /**
@@ -172,7 +57,7 @@ export function graph_k_means_cluster_detailed(
         clusters[i] = [node_index];
     }
 
-    const m_distances = build_distance_matrix(graph, node_array, clusters_seeds, node_index_map);
+    const m_distances = graph_compute_distance_matrix(graph, node_array, clusters_seeds, node_index_map);
 
     for (let node_index = 0; node_index < total_node_count; node_index++) {
 
@@ -218,7 +103,7 @@ export function graph_k_means_cluster(graph, k, random_seed) {
 
     /**
      *
-     * @type {number[]}
+     * @type {Uint8Array}
      */
     const node_cluster_assignments = new Uint8Array(node_count);
     // fill with "UNASSIGNED" value

package/src/core/graph/{coarsen_graph.d.ts → mn_graph_coarsen.d.ts}

@@ -5,5 +5,5 @@
  * @param {Graph<MultiNode<T>>} graph
  * @param {number} max_node_limit Maximum number of "source" nodes per joined node
  */
-export function coarsen_graph<T>(graph: Graph<MultiNode<T>>, max_node_limit: number): void;
-//# sourceMappingURL=coarsen_graph.d.ts.map
+export function mn_graph_coarsen<T>(graph: Graph<MultiNode<T>>, max_node_limit: number): void;
+//# sourceMappingURL=mn_graph_coarsen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mn_graph_coarsen.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/mn_graph_coarsen.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,gFAFW,MAAM,QAuBhB"}

package/src/core/graph/{coarsen_graph.js → mn_graph_coarsen.js}

@@ -9,7 +9,7 @@ import { WeightedEdge } from "./WeightedEdge.js";
  * @param {Graph<MultiNode<T>>} graph
  * @param {number} max_node_limit Maximum number of "source" nodes per joined node
  */
-export function coarsen_graph(graph, max_node_limit) {
+export function mn_graph_coarsen(graph, max_node_limit) {
 
     /**
      *

package/src/core/graph/mn_graph_coarsen.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mn_graph_coarsen.spec.d.ts.map

package/src/core/graph/mn_graph_coarsen.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mn_graph_coarsen.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/mn_graph_coarsen.spec.js"],"names":[],"mappings":""}

package/src/core/graph/{coarsen_graph.spec.js → mn_graph_coarsen.spec.js}

@@ -1,7 +1,7 @@
-import { Graph } from "./v2/Graph.js";
+import { mn_graph_coarsen } from "./mn_graph_coarsen.js";
 import { MultiNode } from "./MultiNode.js";
+import { Graph } from "./v2/Graph.js";
 import { WeightedEdge } from "./WeightedEdge.js";
-import { coarsen_graph } from "./coarsen_graph.js";
 
 test('coarsen 2 node graph with 1 edge', () => {
     const graph = new Graph();
@@ -13,7 +13,7 @@ test('coarsen 2 node graph with 1 edge', () => {
 
     graph.addEdge(new WeightedEdge(n0, n1));
 
-    coarsen_graph(graph, 2);
+    mn_graph_coarsen(graph, 2);
 });
 
 test('coarsen chain, all nodes must still be linked', () => {
@@ -37,7 +37,7 @@ test('coarsen chain, all nodes must still be linked', () => {
         g.addEdge(new WeightedEdge(n0, n1));
     }
 
-    coarsen_graph(g, 100);
+    mn_graph_coarsen(g, 100);
 
     expect(g.getNodeCount()).toBe(1);
 });

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

@@ -1,4 +1,5 @@
 /**
+ * Multi-node graph function
  * @template N
  * @param {Graph<MultiNode<N>>} graph
  * @param {WeightedEdge<MultiNode<N>>} edge

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

@@ -1 +1 @@
-{"version":3,"file":"mn_graph_collapse_weighted_edge.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/mn_graph_collapse_weighted_edge.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,+HAJW,MAAM,2BAEJ,OAAO,CAoEnB"}
+{"version":3,"file":"mn_graph_collapse_weighted_edge.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/mn_graph_collapse_weighted_edge.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,+HAJW,MAAM,2BAEJ,OAAO,CAyEnB"}

package/src/core/graph/mn_graph_collapse_weighted_edge.js

@@ -1,4 +1,5 @@
 /**
+ * Multi-node graph function
  * @template N
  * @param {Graph<MultiNode<N>>} graph
  * @param {WeightedEdge<MultiNode<N>>} edge
@@ -6,7 +7,12 @@
  * @param {BinaryHeap<Edge>} heap
  * @returns {boolean} whether collapse was performed or rejected
  */
-export function mn_graph_collapse_weighted_edge(graph, edge, source_limit, heap) {
+export function mn_graph_collapse_weighted_edge(
+    graph,
+    edge,
+    source_limit,
+    heap
+) {
 
     const successor_node = edge.first;
     const victim_node = edge.second;

package/src/core/math/physics/brdf/brdf_burley.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brdf_burley.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/brdf/brdf_burley.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH,iCANW,MAAM,OACN,MAAM,OACN,MAAM,aACN,MAAM,GACJ,MAAM,CASlB"}
+{"version":3,"file":"brdf_burley.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/brdf/brdf_burley.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;GAaG;AACH,iCANW,MAAM,OACN,MAAM,OACN,MAAM,aACN,MAAM,GACJ,MAAM,CASlB"}

package/src/core/math/physics/brdf/brdf_burley.js

@@ -1,8 +1,16 @@
 import { PI_RECIPROCAL } from "../../PI_RECIPROCAL.js";
+import { fresnel_Schlick } from "./fresnel_Schlick.js";
 
+/**
+ *
+ * @param {number} u
+ * @param {number} f0
+ * @param {number} f90
+ * @return {number}
+ */
 function F_Schlick(u, f0, f90) {
 
-    return f0 + (f90 - f0) * Math.pow(1.0 - u, 5.0);
+    return f0 + (f90 - f0) * fresnel_Schlick(u);
 }
 
 /**

package/src/core/math/physics/brdf/{D_GGX.d.ts → diffuse_GGX.d.ts}

@@ -5,5 +5,5 @@
  * @param {number} roughness
  * @returns {number}
  */
-export function D_GGX(NoH: number, roughness: number): number;
-//# sourceMappingURL=D_GGX.d.ts.map
+export function diffuse_GGX(NoH: number, roughness: number): number;
+//# sourceMappingURL=diffuse_GGX.d.ts.map

package/src/core/math/physics/brdf/diffuse_GGX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diffuse_GGX.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/brdf/diffuse_GGX.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,iCAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAQlB"}

package/src/core/math/physics/brdf/{D_GGX.js → diffuse_GGX.js}

@@ -7,7 +7,7 @@ import { PI_RECIPROCAL } from "../../PI_RECIPROCAL.js";
  * @param {number} roughness
  * @returns {number}
  */
-export function D_GGX(NoH, roughness) {
+export function diffuse_GGX(NoH, roughness) {
     const a = NoH * roughness;
 
     const k = roughness / (1 - NoH * NoH + a * a);