@woosh/meep-engine 2.45.2 → 2.46.1

package/core/graph/graph_k_means_cluster.js

@@ -1,238 +0,0 @@
-//
-import { seededRandom } from "../math/random/seededRandom.js";
-import { SquareMatrix } from "./SquareMatrix.js";
-import { DataType } from "../collection/table/DataType.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, DataType.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;
-}
-
-
-/**
- * @param {MultiNode<T>[]} node_array
- * @param {number} k
- * @param {number} random_seed
- * @param {number[]|Uint8Array|Uint16Array|Uint32Array} node_cluster_assignments
- * @param {Map<T, number>} node_index_map
- * @param {Graph<MultiNode<T>>} graph
- * @returns {number[][]}
- */
-export function graph_k_means_cluster_detailed(
-    node_array,
-    k,
-    random_seed,
-    node_cluster_assignments,
-    node_index_map,
-    graph
-) {
-    const total_node_count = node_array.length;
-
-    if (k > total_node_count) {
-        throw new Error(`Not enough nodes in the graph, K(=${k}) > |V| (=${total_node_count})`);
-    }
-
-    const random = seededRandom(random_seed);
-
-    //seeds
-    const clusters_seeds = [];
-
-    /**
-     *
-     * @type {number[][]}
-     */
-    const clusters = [];
-
-    const UNASSIGNED_CLUSTER = 255;
-
-    // seed clusters
-    for (let i = 0; i < k; i++) {
-        //
-        const node_index = randomIntegerBetween(random, 0, total_node_count);
-
-        if (node_cluster_assignments[node_index] !== UNASSIGNED_CLUSTER) {
-            // node taken, retry
-            i--;
-            continue;
-        }
-
-        node_cluster_assignments[node_index] = i;
-
-        clusters_seeds[i] = node_index;
-        clusters[i] = [node_index];
-    }
-
-    const m_distances = build_distance_matrix(graph, node_array, clusters_seeds, node_index_map);
-
-    for (let node_index = 0; node_index < total_node_count; node_index++) {
-
-        if (node_cluster_assignments[node_index] !== UNASSIGNED_CLUSTER) {
-            // already assigned
-            continue;
-        }
-
-        let closest_cluster = 0;
-        let closest_distance = Number.POSITIVE_INFINITY;
-
-        for (let cluster_index = 0; cluster_index < k; cluster_index++) {
-            const cluster_seed = clusters_seeds[cluster_index];
-
-            const distance = m_distances.getCellValue(cluster_seed, node_index);
-
-            if (distance < closest_distance) {
-                closest_distance = distance;
-                closest_cluster = cluster_index;
-            }
-        }
-
-        // assign node to closest cluster
-        node_cluster_assignments[node_index] = closest_cluster;
-        clusters[closest_cluster].push(node_index);
-    }
-
-    return clusters;
-}
-
-/**
- * Partition graph into K parts using K-means algorithm
- * @template T
- * @param {Graph<T>} graph
- * @param {number} k number of desired parts
- * @param {number} random_seed seed for random number generator, useful for restarting partitioning
- * @returns {number[][]}
- */
-export function graph_k_means_cluster(graph, k, random_seed) {
-
-    const node_array = Array.from(graph.getNodes());
-    const node_count = node_array.length;
-
-    /**
-     *
-     * @type {number[]}
-     */
-    const node_cluster_assignments = new Uint8Array(node_count);
-    // fill with "UNASSIGNED" value
-    node_cluster_assignments.fill(255);
-
-    /**
-     * build node index
-     * @type {Map<T, number>}
-     */
-    const node_index_map = new Map();
-
-    for (let i = 0; i < node_count; i++) {
-        node_index_map.set(node_array[i], i);
-    }
-
-    return graph_k_means_cluster_detailed(node_array, k, random_seed, node_cluster_assignments, node_index_map, graph);
-}

package/core/graph/graph_laplacian_matrix.js

@@ -1,22 +0,0 @@
-import { graph_degree_matrix } from "./graph_degree_matrix.js";
-import { SquareMatrix } from "./SquareMatrix.js";
-import { DataType } from "../collection/table/DataType.js";
-import { graph_adjacency_matrix } from "./graph_adjacency_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
- */
-export function graph_laplacian_matrix(graph, result, node_indices) {
-    const degree = new SquareMatrix(result.size, DataType.Uint8);
-    const adjacency = new SquareMatrix(result.size, DataType.Uint8);
-
-    graph_degree_matrix(graph, degree, node_indices);
-    graph_adjacency_matrix(graph, adjacency, node_indices);
-
-    result.subtractMatrices(degree, adjacency);
-}