@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,151 +0,0 @@
-/*
- * 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

@@ -1,83 +0,0 @@
-#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

@@ -1,59 +0,0 @@
-/*
- * 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

@@ -1,156 +0,0 @@
-/*
- * 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

@@ -1,57 +0,0 @@
-/*
- * 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

@@ -1,43 +0,0 @@
-/*
- * 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

@@ -1,33 +0,0 @@
-/*
- * 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

@@ -1,62 +0,0 @@
-/*
- * 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

@@ -1,31 +0,0 @@
-#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_