@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/centrality/TopHarmonicCloseness.hpp

@@ -0,0 +1,151 @@
+/*
+ * TopHarmonicCloseness.hpp
+ *
+ * Created on: 25.02.2018
+ *		Authors: nemes, Eugenio Angriman
+ */
+
+#ifndef NETWORKIT_CENTRALITY_TOP_HARMONIC_CLOSENESS_HPP_
+#define NETWORKIT_CENTRALITY_TOP_HARMONIC_CLOSENESS_HPP_
+
+#include <memory>
+
+#include <networkit/auxiliary/VectorComparator.hpp>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/components/WeaklyConnectedComponents.hpp>
+#include <networkit/graph/Graph.hpp>
+
+#include <tlx/container/d_ary_addressable_int_heap.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class TopHarmonicCloseness final : public Algorithm {
+public:
+    /**
+     * Finds the top k nodes with highest harmonic closeness centrality faster
+     * than computing it for all nodes. The implementation is based on
+     * "Computing Top-k Centrality Faster in Unweighted Graphs", Bergamini et
+     * al., ALENEX16. The algorithm also works with weighted graphs but only
+     * with the NBcut variation. We recommend to use useNBbound = false for
+     * (weighted) complex networks (or networks with small diameter) and
+     * useNBbound = true for street networks (or networks with large
+     * diameters). Notice that the worst case running time of the algorithm is
+     * O(nm), where n is the number of nodes and m is the number of edges.
+     * However, for most real-world networks the empirical running time is
+     * O(m).
+     *
+     * @param G The input graph. If useNBbound is set to true, edge weights will be ignored.
+     * @param k Number of nodes with highest harmonic closeness that have to be found.
+     * For example, k = 10, the top 10 nodes with highest harmonic closeness will be computed.
+     * @param useNBbound If true, the NBbound variation will be used, otherwise NBcut.
+     */
+    explicit TopHarmonicCloseness(const Graph &G, count k = 1, bool useNBbound = false);
+
+    ~TopHarmonicCloseness() override;
+
+    /**
+     * Computes top-k harmonic closeness on the graph passed in the constructor.
+     */
+    void run() override;
+
+    /**
+     * Returns a list with the k nodes with highest harmonic closeness.
+     * WARNING: closeness centrality of some nodes below the top-k could be equal
+     * to the k-th closeness, we call them trail. Set the parameter includeTrail
+     * to true to also include those nodes but consider that the resulting vector
+     * could be longer than k.
+     *
+     * @param includeTrail Whether or not to include trail nodes.
+     * @return The list of the top-k nodes.
+     */
+    std::vector<node> topkNodesList(bool includeTrail = false);
+
+    /**
+     * Returns a list with the scores of the k nodes with highest harmonic
+     * closeness.
+     * WARNING: closeness centrality of some nodes below the top-k could
+     * be equal to the k-th closeness, we call them trail. Set the parameter
+     * includeTrail to true to also include those centrality values but consider
+     * that the resulting vector could be longer than k.
+     *
+     * @param includeTrail Whether or not to include trail centrality value.
+     * @return The closeness centralities of the k most central nodes.
+     */
+    std::vector<edgeweight> topkScoresList(bool includeTrail = false);
+
+    /**
+     * @brief Restricts the top-k harmonic closeness computation to a subset of nodes.
+     * If the given list is empty, all nodes in the graph will be considered.
+     * Note: Actual existence of included nodes in the graph is not checked.
+     *
+     * @param nodeList Subset of nodes.
+     */
+    void restrictTopKComputationToNodes(const std::vector<node> &nodeList) {
+        nodeListPtr = &nodeList;
+    };
+
+private:
+    const Graph *G;
+    const count k;
+    const bool useNBbound;
+
+    std::vector<double> hCloseness;
+    std::vector<count> reachableNodes;
+    std::vector<std::vector<uint8_t>> visitedGlobal;
+    std::vector<uint8_t> tsGlobal;
+
+    std::vector<node> topKNodes;
+    std::vector<double> topKScores;
+    const std::vector<node> *nodeListPtr;
+
+    // For NBbound
+    std::vector<count> reachU, reachL;
+    std::vector<std::vector<count>> numberOfNodesAtLevelGlobal;
+    std::vector<std::vector<node>> nodesAtCurrentLevelGlobal;
+    std::vector<std::vector<std::vector<node>>> nodesAtLevelGlobal;
+    std::vector<double> levelImprovement;
+    std::unique_ptr<WeaklyConnectedComponents> wccPtr;
+    void updateTimestamp() {
+        auto &visited = visitedGlobal[omp_get_thread_num()];
+        auto &ts = tsGlobal[omp_get_thread_num()];
+        if (ts++ == std::numeric_limits<uint8_t>::max()) {
+            ts = 1;
+            std::fill(visited.begin(), visited.end(), 0);
+        }
+    }
+
+    tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<double>> topKNodesPQ;
+    tlx::d_ary_addressable_int_heap<node, 2, Aux::GreaterInVector<double>> prioQ;
+    std::vector<node> trail;
+
+    // For weighted graphs
+    std::vector<tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<edgeweight>>>
+        dijkstraHeaps;
+    std::vector<std::vector<edgeweight>> distanceGlobal;
+    edgeweight minEdgeWeight;
+
+    omp_lock_t lock;
+
+    void init();
+    void runNBcut();
+    void runNBbound();
+    bool bfscutUnweighted(node source, double kthCloseness);
+    bool bfscutWeighted(node source, double kthCloseness);
+    void bfsbound(node source);
+    void computeReachableNodes();
+    void computeReachableNodesBounds();
+    void computeNeighborhoodBasedBound();
+    void updateTopkPQ(node u);
+
+    double initialBoundNBcutUnweighted(node u) const noexcept;
+    double initialBoundNBcutWeighted(node u) const noexcept;
+
+    template <class Type>
+    std::vector<Type> resizedCopy(const std::vector<Type> &vec) const noexcept;
+};
+
+} // namespace NetworKit
+#endif // NETWORKIT_CENTRALITY_TOP_HARMONIC_CLOSENESS_HPP_

package/vendor/include/networkit/clique/MaximalCliques.hpp

@@ -0,0 +1,83 @@
+#ifndef NETWORKIT_CLIQUE_MAXIMAL_CLIQUES_HPP_
+#define NETWORKIT_CLIQUE_MAXIMAL_CLIQUES_HPP_
+
+#include <functional>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * Algorithm for listing all maximal cliques.
+ *
+ * The implementation is based on the "hybrid" algorithm described in
+ *
+ * Eppstein, D., & Strash, D. (2011).
+ * Listing All Maximal Cliques in Large Sparse Real-World Graphs.
+ * In P. M. Pardalos & S. Rebennack (Eds.),
+ * Experimental Algorithms (pp. 364 - 375). Springer Berlin Heidelberg.
+ * Retrieved from http://link.springer.com/chapter/10.1007/978-3-642-20662-7_31
+ *
+ * The running time of this algorithm should be in @f$O(d^2 \cdot n \cdot 3^{d/3})@f$
+ * where @f$d@f$ is the degeneracy of the graph, i.e., the maximum core number.
+ * The running time in practice depends on the structure of the graph. In
+ * particular for complex networks it is usually quite fast, even graphs with
+ * millions of edges can usually be processed in less than a minute.
+ */
+class MaximalCliques final : public Algorithm {
+
+public:
+    /**
+     * Construct the maximal cliques algorithm with the given graph.
+     *
+     * If the @a maximumOnly argument is set, the algorithm will only store
+     * the clique of maximum size. Further, this enables some optimizations
+     * to skip smaller cliques more efficiently leading to a reduced
+     * running time.
+     *
+     * @param G The graph to list the cliques for.
+     * @param maximumOnly If only a maximum clique shall be found.
+     */
+    MaximalCliques(const Graph &G, bool maximumOnly = false);
+
+    /**
+     * Construct the maximal cliques algorithm with the given graph and a callback.
+     *
+     * The callback is called once for each found clique with a reference to the clique.
+     * Note that the reference is to an internal object, the callback should not assume that
+     * this reference is still valid after it returned.
+     *
+     * @param G The graph to list cliques for
+     * @param callback The callback to call for each clique.
+     */
+    MaximalCliques(const Graph &G, std::function<void(const std::vector<node> &)> callback);
+
+    /**
+     * Execute the maximal clique listing algorithm.
+     */
+    void run() override;
+
+    /**
+     * Return all found cliques unless a callback was given.
+     *
+     * This method will throw if a callback was given and thus the cliques were not stored.
+     * If only the maximum clique was stored, it will return exactly one clique unless the graph
+     * is empty.
+     *
+     * @return a vector of cliques, each being represented as a vector of nodes.
+     */
+    const std::vector<std::vector<node>> &getCliques() const;
+
+private:
+    const Graph *G;
+
+    std::vector<std::vector<node>> result;
+
+    std::function<void(const std::vector<node> &)> callback;
+    bool maximumOnly;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_CLIQUE_MAXIMAL_CLIQUES_HPP_

package/vendor/include/networkit/coarsening/ClusteringProjector.hpp

@@ -0,0 +1,59 @@
+/*
+ * ClusteringProjector.hpp
+ *
+ *  Created on: 07.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_COARSENING_CLUSTERING_PROJECTOR_HPP_
+#define NETWORKIT_COARSENING_CLUSTERING_PROJECTOR_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup coarsening
+ */
+class ClusteringProjector {
+
+public:
+    /**
+     * Given
+     * 		@param[in]	Gcoarse
+     * 		@param[in] 	Gfine
+     * 		@param[in]	fineToCoarse
+     * 		@param[in]	zetaCoarse	a clustering of the coarse graph
+     *
+     * 	, project the clustering back to the fine graph to create a clustering of the fine graph.
+     * 		@param[out] 			a clustering of the fine graph
+     **/
+    virtual Partition projectBack(const Graph &Gcoarse, const Graph &Gfine,
+                                  const std::vector<node> &fineToCoarse,
+                                  const Partition &zetaCoarse);
+
+    /**
+     * Project a clustering \zeta^{i} of the coarse graph G^{i} back to
+     * the finest graph G^{0}, using the hierarchy of fine->coarse maps
+     */
+    virtual Partition projectBackToFinest(const Partition &zetaCoarse,
+                                          const std::vector<std::vector<node>> &maps,
+                                          const Graph &Gfinest);
+
+    /**
+     * Assuming that the coarse graph resulted from contracting and represents a clustering of the
+     * finest graph
+     *
+     * @param[in]	Gcoarse		coarse graph
+     * @param[in]	Gfinest		finest graph
+     * @param[in]	maps		hierarchy of maps M^{i->i+1} mapping nodes in finer graph to
+     * supernodes in coarser graph
+     */
+    virtual Partition
+    projectCoarseGraphToFinestClustering(const Graph &Gcoarse, const Graph &Gfinest,
+                                         const std::vector<std::vector<node>> &maps);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COARSENING_CLUSTERING_PROJECTOR_HPP_

package/vendor/include/networkit/coarsening/CoarsenedGraphView.hpp

@@ -0,0 +1,156 @@
+/*
+ * CoarsenedGraphView.hpp
+ *
+ *  Memory-efficient layered graph view for coarsening operations
+ */
+
+#ifndef NETWORKIT_COARSENING_COARSENED_GRAPH_VIEW_HPP_
+#define NETWORKIT_COARSENING_COARSENED_GRAPH_VIEW_HPP_
+
+#include <vector>
+#include <networkit/Globals.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup coarsening
+ * Memory-efficient view of a coarsened graph that avoids creating new graph structures.
+ * This class provides a graph-like interface over the original CSR graph by maintaining
+ * only the node mapping information, computing edges on-demand.
+ */
+class CoarsenedGraphView {
+public:
+    /**
+     * Construct a coarsened graph view from the original graph and partition.
+     * @param originalGraph The original CSR graph
+     * @param partition Partition defining how nodes are grouped into supernodes
+     */
+    CoarsenedGraphView(const Graph &originalGraph, const Partition &partition);
+
+    /**
+     * Get the number of nodes (supernodes) in the coarsened view
+     */
+    count numberOfNodes() const { return numSupernodes; }
+
+    /**
+     * Get the number of edges in the coarsened view
+     */
+    count numberOfEdges() const;
+
+    /**
+     * Check if a supernode exists
+     */
+    bool hasNode(node supernode) const { return supernode < numSupernodes; }
+
+    /**
+     * Get the degree of a supernode (number of adjacent supernodes)
+     */
+    count degree(node supernode) const;
+
+    /**
+     * Get the weighted degree of a supernode
+     * @param countSelfLoopsTwice If true, count self-loops twice (for undirected graphs)
+     */
+    edgeweight weightedDegree(node supernode, bool countSelfLoopsTwice = false) const;
+
+    /**
+     * Check if there's an edge between two supernodes
+     */
+    bool hasEdge(node u, node v) const;
+
+    /**
+     * Get the weight of an edge between two supernodes
+     */
+    edgeweight weight(node u, node v) const;
+
+    /**
+     * Iterate over neighbors of a supernode
+     * @param supernode The supernode to iterate neighbors for
+     * @param handle Function to call for each neighbor: void(node neighbor, edgeweight weight)
+     */
+    template <typename Lambda>
+    void forNeighborsOf(node supernode, Lambda handle) const {
+        if (!hasNode(supernode))
+            return;
+
+        auto neighbors = getNeighbors(supernode);
+        for (const auto &entry : neighbors) {
+            handle(entry.first, entry.second);
+        }
+    }
+
+    /**
+     * Iterate over all edges in the coarsened view
+     * @param handle Function to call for each edge: void(node u, node v, edgeweight weight)
+     */
+    template <typename Lambda>
+    void forEdges(Lambda handle) const {
+        for (node u = 0; u < numberOfNodes(); ++u) {
+            forNeighborsOf(u, [&](node v, edgeweight w) {
+                if (u <= v) { // Only report each edge once for undirected graphs
+                    handle(u, v, w);
+                }
+            });
+        }
+    }
+
+    /**
+     * Parallel iteration over nodes
+     */
+    template <typename Lambda>
+    void parallelForNodes(Lambda handle) const {
+#pragma omp parallel for
+        for (omp_index u = 0; u < static_cast<omp_index>(numberOfNodes()); ++u) {
+            handle(static_cast<node>(u));
+        }
+    }
+
+    /**
+     * Get the mapping from original nodes to supernodes
+     */
+    const std::vector<node> &getNodeMapping() const { return nodeMapping; }
+
+    /**
+     * Get original nodes that belong to a supernode
+     */
+    const std::vector<node> &getOriginalNodes(node supernode) const;
+
+    /**
+     * Check if the graph is weighted (always true for coarsened views)
+     */
+    bool isWeighted() const { return true; }
+
+    /**
+     * Check if the graph is directed (always false for current implementation)
+     */
+    bool isDirected() const { return false; }
+
+    /**
+     * Get upper bound for node IDs
+     */
+    node upperNodeIdBound() const { return numSupernodes; }
+
+private:
+    const Graph &originalGraph;
+    std::vector<node> nodeMapping;                      // original_node -> supernode
+    std::vector<std::vector<node>> supernodeToOriginal; // supernode -> [original_nodes]
+    count numSupernodes;
+
+    /**
+     * Get neighbors of a supernode (compute on demand, no caching)
+     */
+    std::vector<std::pair<node, edgeweight>> getNeighbors(node supernode) const {
+        return computeNeighbors(supernode);
+    }
+
+    /**
+     * Compute neighbors of a supernode
+     */
+    std::vector<std::pair<node, edgeweight>> computeNeighbors(node supernode) const;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_COARSENING_COARSENED_GRAPH_VIEW_HPP_

package/vendor/include/networkit/coarsening/GraphCoarsening.hpp

@@ -0,0 +1,57 @@
+/*
+ * GraphCoarsening.hpp
+ *
+ *  Created on: 30.10.2012
+ *      Author: Christian Staudt (christian.staudt@kit.edu)
+ */
+
+#ifndef NETWORKIT_COARSENING_GRAPH_COARSENING_HPP_
+#define NETWORKIT_COARSENING_GRAPH_COARSENING_HPP_
+
+#include <map>
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup coarsening
+ * Abstract base class for graph coarsening/contraction algorithms.
+ */
+class GraphCoarsening : public Algorithm {
+
+public:
+    GraphCoarsening(const Graph &G);
+
+    ~GraphCoarsening() override = default;
+
+    void run() override = 0;
+
+    const GraphW &getCoarseGraph() const;
+
+    GraphW &getCoarseGraph();
+
+    /**
+     * Get mapping from fine to coarse node.
+     */
+    const std::vector<node> &getFineToCoarseNodeMapping() const;
+
+    std::vector<node> &getFineToCoarseNodeMapping();
+
+    /**
+     * Get mapping from coarse node to collection of fine nodes.
+     */
+    std::map<node, std::vector<node>> getCoarseToFineNodeMapping() const;
+
+protected:
+    const Graph *G;
+    GraphW Gcoarsened;
+    std::vector<node> nodeMapping;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COARSENING_GRAPH_COARSENING_HPP_

package/vendor/include/networkit/coarsening/MatchingCoarsening.hpp

@@ -0,0 +1,43 @@
+/*
+ * MatchingCoarsening.hpp
+ *
+ *  Created on: 30.10.2012
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_COARSENING_MATCHING_COARSENING_HPP_
+#define NETWORKIT_COARSENING_MATCHING_COARSENING_HPP_
+
+#include <networkit/coarsening/GraphCoarsening.hpp>
+#include <networkit/graph/GraphW.hpp>
+#include <networkit/matching/Matching.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup coarsening
+ * Coarsens graph according to a matching.
+ */
+class MatchingCoarsening final : public GraphCoarsening {
+
+public:
+    MatchingCoarsening(const Graph &G, const Matching &M, bool noSelfLoops = false);
+
+    /**
+     * Contracts graph according to a matching.
+     *
+     * @param[in]	G	fine graph
+     * @param[in]	M	matching
+     * @param[in]	noSelfLoops  if true, self-loops are not produced
+     *
+     * @return		coarse graph
+     */
+    void run() override;
+
+private:
+    const Matching &M;
+    bool noSelfLoops;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COARSENING_MATCHING_COARSENING_HPP_

package/vendor/include/networkit/coarsening/ParallelPartitionCoarsening.hpp

@@ -0,0 +1,33 @@
+/*
+ * ParallelPartitionCoarsening.hpp
+ *
+ *  Created on: 03.07.2014
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_COARSENING_PARALLEL_PARTITION_COARSENING_HPP_
+#define NETWORKIT_COARSENING_PARALLEL_PARTITION_COARSENING_HPP_
+
+#include <networkit/Globals.hpp>
+#include <networkit/coarsening/GraphCoarsening.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup coarsening
+ */
+class ParallelPartitionCoarsening final : public GraphCoarsening {
+public:
+    ParallelPartitionCoarsening(const Graph &G, const Partition &zeta, bool parallel = true);
+
+    void run() override;
+
+private:
+    const Partition &zeta;
+    bool parallel;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_COARSENING_PARALLEL_PARTITION_COARSENING_HPP_

package/vendor/include/networkit/coarsening/ParallelPartitionCoarseningView.hpp

@@ -0,0 +1,62 @@
+/*
+ * ParallelPartitionCoarseningView.hpp
+ *
+ *  Memory-efficient partition coarsening using views
+ */
+
+#ifndef NETWORKIT_COARSENING_PARALLEL_PARTITION_COARSENING_VIEW_HPP_
+#define NETWORKIT_COARSENING_PARALLEL_PARTITION_COARSENING_VIEW_HPP_
+
+#include <memory>
+#include <networkit/Globals.hpp>
+#include <networkit/coarsening/CoarsenedGraphView.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup coarsening
+ * Memory-efficient partition coarsening that creates a CoarsenedGraphView
+ * instead of a new graph structure, significantly reducing memory usage.
+ */
+class ParallelPartitionCoarseningView {
+public:
+    /**
+     * Constructor
+     * @param G The input graph
+     * @param zeta The partition defining how nodes should be grouped
+     */
+    ParallelPartitionCoarseningView(const Graph &G, const Partition &zeta);
+
+    /**
+     * Run the coarsening algorithm
+     */
+    void run();
+
+    /**
+     * Get the coarsened graph view
+     * @return Shared pointer to the coarsened graph view
+     */
+    std::shared_ptr<CoarsenedGraphView> getCoarsenedGraphView() const { return coarsenedView; }
+
+    /**
+     * Get the mapping from fine to coarse nodes
+     * @return Vector mapping original node IDs to coarsened node IDs
+     */
+    const std::vector<node> &getFineToCoarseNodeMapping() const;
+
+    /**
+     * Check if the algorithm has been run
+     */
+    bool hasRun() const { return hasRunFlag; }
+
+private:
+    const Graph *G;
+    const Partition &zeta;
+    std::shared_ptr<CoarsenedGraphView> coarsenedView;
+    bool hasRunFlag;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_COARSENING_PARALLEL_PARTITION_COARSENING_VIEW_HPP_

package/vendor/include/networkit/community/AdjustedRandMeasure.hpp

@@ -0,0 +1,31 @@
+#ifndef NETWORKIT_COMMUNITY_ADJUSTED_RAND_MEASURE_HPP_
+#define NETWORKIT_COMMUNITY_ADJUSTED_RAND_MEASURE_HPP_
+
+#include <networkit/community/DissimilarityMeasure.hpp>
+
+namespace NetworKit {
+
+/**
+ * The adjusted rand dissimilarity measure as proposed by Huber and Arabie in "Comparing partitions"
+ * (http://link.springer.com/article/10.1007/BF01908075)
+ */
+class AdjustedRandMeasure final : public DissimilarityMeasure {
+public:
+    /**
+     * Get the adjust rand dissimilarity. Runs in O(n log(n)).
+     *
+     * Note that the dissimilarity can be larger than 1 if the partitions are more different than
+     * expected in the random model.
+     *
+     * @param G    The graph on which the partitions shall be compared
+     * @param zeta The first partiton
+     * @param eta  The second partition
+     * @return The adjusted rand dissimilarity.
+     */
+    double getDissimilarity(const Graph &G, const NetworKit::Partition &zeta,
+                            const NetworKit::Partition &eta) override;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_ADJUSTED_RAND_MEASURE_HPP_