@ladybugmem/icebug 0.1.0 → 0.1.2

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

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

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

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

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

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

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

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