@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/base/DynAlgorithm.hpp

@@ -0,0 +1,31 @@
+#ifndef NETWORKIT_BASE_DYN_ALGORITHM_HPP_
+#define NETWORKIT_BASE_DYN_ALGORITHM_HPP_
+
+#include <stdexcept>
+#include <string>
+#include <networkit/dynamics/GraphEvent.hpp>
+
+namespace NetworKit {
+
+class DynAlgorithm {
+
+public:
+    /**
+     * Virtual default destructor
+     */
+    virtual ~DynAlgorithm() = default;
+
+    /**
+     * The generic update method for updating data structure after an update.
+     */
+    virtual void update(GraphEvent e) = 0;
+
+    /**
+     * The generic update method for updating data structure after a batch of updates.
+     */
+    virtual void updateBatch(const std::vector<GraphEvent> &batch) = 0;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_BASE_DYN_ALGORITHM_HPP_

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

@@ -0,0 +1,62 @@
+/*
+ * ApproxBetweenness.hpp
+ *
+ *  Created on: 09.04.2014
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_CENTRALITY_APPROX_BETWEENNESS_HPP_
+#define NETWORKIT_CENTRALITY_APPROX_BETWEENNESS_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Approximation of betweenness centrality according to algorithm described in
+ * Matteo Riondato and Evgenios M. Kornaropoulos: Fast Approximation of Betweenness Centrality
+ * through Sampling
+ */
+class ApproxBetweenness final : public Centrality {
+
+public:
+    /**
+     * The algorithm approximates the betweenness of all vertices so that the scores are
+     * within an additive error @a epsilon with probability at least (1- @a delta).
+     * The values are normalized by default. The run() method takes O(m) time per sample, where  m
+     * is the number of edges of the graph. The number of samples is proportional to
+     * universalConstant/epsilon^2. Although this algorithm has a theoretical guarantee, the
+     * algorithm implemented in Estimate Betweenness usually performs better in practice Therefore,
+     * we recommend to use EstimateBetweenness if no theoretical guarantee is needed.
+     *
+     * @param	G			the graph
+     * @param	epsilon		maximum additive error
+     * @param	delta		probability that the values are within the error guarantee
+     * @param   universalConstant   the universal constant to be used in
+     * computing the sample size. It is 1 by default. Some references suggest
+     * using 0.5, but there is no guarantee in this case.
+     */
+    ApproxBetweenness(const Graph &G, double epsilon = 0.01, double delta = 0.1,
+                      double universalConstant = 1.0);
+
+    /**
+     * Computes betweenness approximation on the graph passed in constructor.
+     */
+    void run() override;
+
+    /**
+     * @return number of samples taken in last run
+     */
+    count numberOfSamples() const;
+
+private:
+    const double epsilon;
+    const double delta;
+    count r; // number of samples taken in last run
+    double universalConstant;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_APPROX_BETWEENNESS_HPP_

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

@@ -0,0 +1,136 @@
+/*
+ * ApproxCloseness.hpp
+ *
+ *  Created on: Dec 8, 2015
+ *      Author: Sarah Lutteropp (uwcwa@student.kit.edu) and Michael Wegner
+ *      (michael.wegner@student.kit.edu)
+ */
+
+#ifndef NETWORKIT_CENTRALITY_APPROX_CLOSENESS_HPP_
+#define NETWORKIT_CENTRALITY_APPROX_CLOSENESS_HPP_
+
+#include <limits>
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Approximation of closeness centrality according to algorithm described in
+ * Cohen et al., Computing Classic Closeness Centrality, at Scale
+ */
+class ApproxCloseness : public Centrality {
+
+public:
+    enum ClosenessType { INBOUND, OUTBOUND, SUM };
+
+    using CLOSENESS_TYPE = ClosenessType; // enum alias for backwards compatibility
+
+    /**
+     * Constructs an instance of the ApproxCloseness class for @a graph using @a nSamples during the
+     * run() method. The @a epsilon parameter (standard = 0.1) is used to control the switch between
+     * sampling and pivoting. Using @a epsilon = 0, the algorithm only uses sampling. (see Cohen,
+     * Edith, et al. "Computing classic closeness centrality, at scale." Proceedings of the second
+     * ACM conference on Online social networks. ACM, 2014.). The running time is proportional to
+     * nSamples * m, where m is  the number of edges. Notice: the input graph has to be connected.
+     * @param	graph		input graph
+     * @param	nSamples	user defined number of samples
+     * @param 	epsilon		Value in [0, infty) controlling the switch between sampling and
+     * pivoting. When using 0, only sampling is used. Standard is 0.1.
+     * @param	normalized  normalize centrality values in interval [0,1]
+     * @param 	type		use in- or outbound centrality or the sum of both (see paper) for
+     * computing closeness on directed graph. If G is undirected, this can be ignored.
+     */
+    ApproxCloseness(const Graph &G, count nSamples, double epsilon = 0.1, bool normalized = false,
+                    CLOSENESS_TYPE type = OUTBOUND);
+
+    /**
+     * Computes closeness approximation on the graph passed in constructor.
+     */
+    void run() override;
+
+    /**
+     * Returns the maximum possible Closeness a node can have in a graph with the same amount of
+     * nodes (=a star)
+     */
+    double maximum() override;
+
+    /**
+     * @return The square error when closeness centrality has been computed for an undirected graph.
+     */
+    std::vector<double> getSquareErrorEstimates();
+
+private:
+    count nSamples;
+    double epsilon;
+
+    /** \sum_{i \in L(j) \cap C} d_{ji} for every j \in V */
+    std::vector<double> LCSum;
+
+    /** |L(j) \cap C| for every j \in V */
+    std::vector<count> LCNum;
+
+    /** \sum_{i \in L(j) \cap C} d_{ji}^2 for every j \in V */
+    std::vector<double> LCSumSQ;
+
+    /** \sum_{i \in HC(j)} d_{ji} for every j \in V */
+    std::vector<double> HCSum;
+
+    /** \frac{1}{|HC(j)|} * \sum_{i \in HC(j)} (d_{ij} - d_{c(j)j})^2 for every j \in V */
+    std::vector<double> HCSumSQErr;
+
+    /** \sum_{i \in H(j)} d_{c(j)i} for every j \in V */
+    std::vector<double> HSum;
+
+    /** |H(j)| for every j \in V */
+    std::vector<count> HNum;
+
+    /** Reachability estimation **/
+    std::vector<double> R;
+
+    std::vector<double> SQErrEst;
+
+    // divided by two s.t. infDist + infDist produces no overflow
+    const edgeweight infDist = std::floor(std::numeric_limits<edgeweight>::max() / 2.0);
+
+    ClosenessType type = ApproxCloseness::ClosenessType::OUTBOUND;
+
+    void estimateClosenessForUndirectedGraph();
+    void estimateClosenessForDirectedGraph(bool outbound);
+    inline void computeClosenessForDirectedWeightedGraph(bool outbound);
+    inline void computeClosenessForDirectedUnweightedGraph(bool outbound);
+
+    /**
+     * Runs a multi-source Dijkstra from all @a samples and sets the closest pivot and the distance
+     * from it for every node in G.
+     * @param samples The sampled nodes that are the pivot nodes.
+     * @param pivot[out] Stores the closest pivot (sample) from every node.
+     * @param delta[out] Stores the distance d(u,pivot(u)) for every node u.
+     */
+    void computeClosestPivot(const std::vector<node> &samples, std::vector<node> &pivot,
+                             std::vector<edgeweight> &delta);
+
+    /**
+     * Runs the algorithm of Cohen et al. for a single pivot.
+     * @param i
+     * @param pivot
+     * @param delta
+     * @param samples
+     */
+    void runOnPivot(index i, const std::vector<node> &pivot, const std::vector<edgeweight> &delta,
+                    const std::vector<node> &samples);
+
+    /**
+     * Orders the nodes of G in increasing distance from @a pivot. The distances from @a pivot are
+     * stored in @a pivotDist
+     * @param pivot
+     * @param order[out]
+     * @param pivotDist[out]
+     */
+    void orderNodesByIncreasingDistance(node pivot, std::vector<node> &order,
+                                        std::vector<edgeweight> &pivotDist);
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_APPROX_CLOSENESS_HPP_

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

@@ -0,0 +1,156 @@
+/*
+ * ApproxElectricalCloseness.hpp
+ *
+ *  Created on: 17.10.2019
+ *     Authors: Eugenio Angriman <angrimae@hu-berlin.de>
+ *              Alexander van der Grinten <avdgrinten@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_CENTRALITY_APPROX_ELECTRICAL_CLOSENESS_HPP_
+#define NETWORKIT_CENTRALITY_APPROX_ELECTRICAL_CLOSENESS_HPP_
+
+#include <cmath>
+#include <memory>
+#include <random>
+#include <unordered_map>
+#include <vector>
+
+#include <networkit/centrality/Centrality.hpp>
+#include <networkit/components/BiconnectedComponents.hpp>
+#include <networkit/distance/Diameter.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class ApproxElectricalCloseness final : public Centrality {
+
+public:
+    /**
+     * Approximates the electrical closeness of all the vertices of the graph by approximating the
+     * diagonal of the laplacian's pseudoinverse of @a G. Every element of the diagonal is
+     * guaranteed to have a maximum absolute error of @a epsilon. Based on "Approximation of the
+     * Diagonal of a Laplacian’s Pseudoinverse for Complex Network Analysis", Angriman et al., ESA
+     * 2020. The algorithm does two steps: solves a linear system and samples uniform spanning trees
+     * (USTs). The parameter @a kappa balances the tolerance of solver for the linear system and the
+     * number of USTs to be sampled. A high value of @a kappa raises the tolerance (solver converges
+     * faster) but more USTs need to be sampled, vice versa for a low value of @a kappa.
+     *
+     * @param G The input graph.
+     * @param epsilon Maximum absolute error of the elements in the diagonal.
+     * @param kappa Balances the tolerance of the solver for the linear system and the number of
+     * USTs to be sampled.
+     */
+    ApproxElectricalCloseness(const Graph &G, double epsilon = 0.1, double kappa = 0.3);
+
+    ~ApproxElectricalCloseness() override = default;
+
+    /**
+     * Run the algorithm.
+     */
+    void run() override;
+
+    /**
+     * Return an epsilon-approximation of the diagonal of the laplacian's pseudoinverse.
+     *
+     * @return Approximation of the diagonal of the laplacian's pseudoinverse.
+     */
+    const std::vector<double> &getDiagonal() const {
+        assureFinished();
+        return diagonal;
+    }
+
+    /**
+     * Compute and return the nearly-exact values of the diagonal of the laplacian's pseudoinverse.
+     * The values are computed by solving Lx = e_u - 1 / n for every vertex u of the graph with a
+     * LAMG solver.
+     *
+     * @param tol Tolerance for the LAMG solver.
+     *
+     * @return Nearly-exact values of the diagonal of the laplacian's pseudoinverse.
+     */
+    std::vector<double> computeExactDiagonal(double tol = 1e-9) const;
+
+private:
+    const double epsilon, delta, kappa;
+    node root = 0;
+    count rootEcc;
+
+    // #of BFSs used to estimate a vertex with low eccentricity.
+    static constexpr uint32_t sweeps = 10;
+
+    enum class NodeStatus : unsigned char {
+        NOT_IN_COMPONENT,
+        IN_SPANNING_TREE,
+        NOT_VISITED,
+        VISITED
+    };
+
+    // Used to mark the status of each node, one vector per thread
+    std::vector<std::vector<NodeStatus>> statusGlobal;
+
+    std::unique_ptr<BiconnectedComponents> bccPtr;
+
+    // Nodes in each biconnected components sorted by their degree.
+    std::vector<std::vector<node>> sequences;
+
+    // Pointers to the parent of the UST, one vector per thread
+    std::vector<std::vector<node>> parentGlobal;
+
+    // Index of the parent component of the current component (after the topological order has been
+    // determined)
+    std::vector<index> biParent;
+    // Node within the biconnected component that points to the node in the parent component
+    std::vector<node> biAnchor;
+
+    // Topological order of the biconnected components
+    std::vector<index> topOrder;
+
+    // Non-normalized approx effective resistance, one per thread.
+    // Values could be negative, so we use signed integers.
+    std::vector<std::vector<int64_t>> approxEffResistanceGlobal;
+
+    // Pseudo-inverse diagonal
+    std::vector<double> diagonal;
+
+    // Timestamps for DFS
+    std::vector<std::vector<count>> tVisitGlobal, tFinishGlobal;
+
+    // Random number generators
+    std::vector<std::mt19937_64> generators;
+    std::vector<std::uniform_int_distribution<index>> degDist;
+
+    // Parent pointers of the bfs tree
+    std::vector<node> bfsParent;
+
+    // Nodes sequences: Wilson's algorithm runs faster if we start the random walks following a
+    // specific sequence of nodes. In this function we compute those sequences.
+    void computeNodeSequence();
+
+    // Adjacency list for trees: additional data structure to speed-up the DFS
+    std::vector<std::vector<node>> ustChildPtrGlobal;
+    std::vector<std::vector<node>> ustSiblingPtrGlobal;
+
+    void computeBFSTree();
+    void sampleUST();
+    void dfsUST();
+    void aggregateUST();
+
+    node approxMinEccNode();
+
+    count computeNumberOfUSTs() const;
+
+#ifdef NETWORKIT_SANITY_CHECKS
+    // Debugging methods
+    void checkBFSTree() const;
+    void checkUST() const;
+    void checkTwoNodesSequence(const std::vector<node> &sequence) const;
+    void checkTimeStamps() const;
+#endif // NETWORKIT_SANITY_CHECKS
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_CENTRALITY_APPROX_ELECTRICAL_CLOSENESS_HPP_

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

@@ -0,0 +1,124 @@
+/*
+ * ApproxGroupBetweenness.hpp
+ *
+ *  Created on: 13.03.2018
+ *      Author: Marvin Pogoda
+ */
+#ifndef NETWORKIT_CENTRALITY_APPROX_GROUP_BETWEENNESS_HPP_
+#define NETWORKIT_CENTRALITY_APPROX_GROUP_BETWEENNESS_HPP_
+
+#include <omp.h>
+#include <ranges>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/distance/BFS.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+class ApproxGroupBetweenness final : public Algorithm {
+
+public:
+    /** Constructs the ApproxGroupBetweenness class for a given undirected graph
+     * @a G.
+     * @param groupSize Size of the set of nodes.
+     * @aram epsilon Determines the accuracy of the approximation.
+     */
+    ApproxGroupBetweenness(const Graph &G, count groupSize, double epsilon);
+
+    /**
+     * Approximately computes a set of nodes with maximum groupbetweenness. Based
+     * on the algorithm of Mahmoody,Tsourakakis and Upfal.
+     */
+    void run() override;
+
+    /**
+     * Returns a vector of nodes containing the set of nodes with approximated
+     * maximum group betweenness.
+     */
+    std::vector<node> groupMaxBetweenness() const;
+
+    /**
+     * Returns the score of the given set.
+     */
+    double scoreOfGroup(const std::vector<node> &S, bool normalized = false) const;
+
+protected:
+    const Graph &G;
+    count n;
+    std::vector<node> maxGroup;
+    const count groupSize;
+    const double epsilon;
+};
+
+inline std::vector<node> ApproxGroupBetweenness::groupMaxBetweenness() const {
+    assureFinished();
+    return maxGroup;
+}
+
+inline double ApproxGroupBetweenness::scoreOfGroup(const std::vector<node> &S,
+                                                   const bool normalized) const {
+    if (S.empty())
+        throw std::runtime_error("Error: input group is empty");
+
+    count z = G.upperNodeIdBound();
+    std::vector<bool> inGroup(z);
+    for (node u : S) {
+        if (!G.hasNode(u))
+            throw std::runtime_error("Error, input group contains nodes not in the graph");
+        if (inGroup[u])
+            WARN("Input group contains duplicate nodes!");
+        inGroup[u] = true;
+    }
+
+    std::vector<double> scorePerThread(omp_get_max_threads());
+    std::vector<std::vector<double>> deps(omp_get_max_threads(), std::vector<double>(n));
+    std::vector<BFS> bfss(omp_get_max_threads(), BFS(G, 0, true, true));
+
+    auto computeDeps = [&](node source) {
+        auto &dep = deps[omp_get_thread_num()];
+        std::ranges::fill(dep, 0);
+
+        BFS &bfs = bfss[omp_get_thread_num()];
+        bfs.setSource(source);
+        bfs.run();
+
+        double weight;
+        auto sortedNodes = bfs.getNodesSortedByDistance();
+        for (auto it = sortedNodes.rbegin(); it != sortedNodes.rend(); ++it) {
+            node target = *it;
+            for (node pred : bfs.getPredecessors(target)) {
+                (bfs.numberOfPaths(pred) / bfs.numberOfPaths(target)).ToDouble(weight);
+                if (inGroup[pred]) {
+                    if (pred != source) {
+                        scorePerThread[omp_get_thread_num()] +=
+                            dep[pred] + weight * (1 + dep[target]);
+                    }
+                } else {
+                    dep[pred] += weight * (1 + dep[target]);
+                }
+            }
+        }
+    };
+
+    G.balancedParallelForNodes(computeDeps);
+
+    double result = 0;
+    for (double curScore : scorePerThread)
+        result += curScore;
+
+    if (normalized) {
+        double nPairs = static_cast<double>((z - S.size()) * (z - S.size() - 1));
+        if (nPairs <= 0)
+            return 0;
+        if (!G.isDirected())
+            nPairs /= 2;
+        result /= nPairs;
+    }
+
+    return result;
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_APPROX_GROUP_BETWEENNESS_HPP_

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

@@ -0,0 +1,84 @@
+/*
+ * ApproxSpanningEdge.hpp
+ *
+ *  Created on: 29.09.2019
+ *     Authors: Eugenio Angriman <angrimae@hu-berlin.de>
+ *
+ */
+
+#ifndef NETWORKIT_CENTRALITY_APPROX_SPANNING_EDGE_HPP_
+#define NETWORKIT_CENTRALITY_APPROX_SPANNING_EDGE_HPP_
+
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class ApproxSpanningEdge final : public Algorithm {
+
+    enum class NodeStatus : unsigned char {
+        NOT_IN_COMPONENT,
+        IN_SPANNING_TREE,
+        IN_RANDOM_WALK,
+        NOT_VISITED
+    };
+
+public:
+    /**
+     * Computes an epsilon-approximation of the spanning edge centrality of every edge of the input
+     * graph with probability (1 - 1/n), based on "Efficient Algorithms for Spanning Tree
+     * Centrality", Hayashi et al., IJCAI, 2016. This implementation also supports multi-threading.
+     *
+     * @param G An undirected graph.
+     * @param eps Maximum additive error.
+     */
+    ApproxSpanningEdge(const Graph &G, double eps = 0.1);
+
+    ~ApproxSpanningEdge() override = default;
+
+    /**
+     * Executes the algorithm.
+     */
+    void run() override;
+
+    /**
+     * Return the spanning edge approximation for each edge of the graph.
+     *
+     * @return Spanning edge approximation for each edge of the input graph.
+     */
+    std::vector<double> scores() const;
+
+private:
+    const Graph &G;
+    double eps;
+    double delta;
+    count nSamples;
+
+    // For each thread, marks which nodes have been visited by the random walk.
+    std::vector<std::vector<NodeStatus>> visitedNodes;
+
+    // For each thread, counts how many times each edge appears in a random
+    // spanning tree.
+    std::vector<std::vector<count>> edgeScores;
+
+    // Sequence of biconnected components.
+    std::vector<std::vector<node>> sequences;
+
+    // Parent pointers.
+    std::vector<std::vector<node>> parents;
+
+    // Ids of edge connecting the nodes to their parents.
+    std::vector<std::vector<edgeid>> parentsEdgeIds;
+
+    // Samples a spanning tree uniformly at random.
+    void sampleUST();
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_CENTRALITY_APPROX_SPANNING_EDGE_HPP_

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

@@ -0,0 +1,47 @@
+/*
+ * Betweenness.hpp
+ *
+ *  Created on: 19.02.2014
+ *      Author: cls, ebergamini
+ */
+
+#ifndef NETWORKIT_CENTRALITY_BETWEENNESS_HPP_
+#define NETWORKIT_CENTRALITY_BETWEENNESS_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class Betweenness final : public Centrality {
+public:
+    /**
+     * Constructs the Betweenness class for the given Graph @a G. If the betweenness scores should
+     * be normalized, then set @a normalized to <code>true</code>. The run() method takes O(nm)
+     * time, where n is the number of nodes and m is the number of edges of the graph.
+     *
+     * @param G The graph.
+     * @param normalized Set this parameter to <code>true</code> if scores should be normalized in
+     * the interval [0,1].
+     * @param computeEdgeCentrality Set this parameter to <code>true</code> if edge betweenness
+     * should be computed as well.
+     */
+    Betweenness(const Graph &G, bool normalized = false, bool computeEdgeCentrality = false);
+
+    /**
+     * Computes betweenness scores on the graph passed in constructor.
+     */
+    void run() override;
+
+    /*
+     * Returns the maximum possible Betweenness a node can have in a graph with the same amount of
+     * nodes (=a star)
+     */
+    double maximum() override;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_BETWEENNESS_HPP_