@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,99 @@
+/*
+ * DynBetweenness.hpp
+ *
+ *  Created on: 12.08.2015
+ *      Author: Arie Slobbe, Elisabetta Bergamini
+ */
+
+#ifndef NETWORKIT_CENTRALITY_DYN_BETWEENNESS_HPP_
+#define NETWORKIT_CENTRALITY_DYN_BETWEENNESS_HPP_
+
+#include <memory>
+#include <queue>
+
+#include <networkit/auxiliary/PrioQueue.hpp>
+#include <networkit/base/DynAlgorithm.hpp>
+#include <networkit/centrality/Centrality.hpp>
+#include <networkit/dynamics/GraphEvent.hpp>
+
+namespace NetworKit {
+
+class CompareDist {
+public:
+    bool operator()(std::pair<double, node> n1, std::pair<double, node> n2) {
+        return n1.first > n2.first;
+    }
+};
+
+using PrioQ =
+    std::priority_queue<std::pair<double, node>, std::vector<std::pair<double, node>>, CompareDist>;
+
+/**
+ * @ingroup centrality
+ * Dynamic APSP.
+ */
+class DynBetweenness : public Centrality, public DynAlgorithm {
+
+public:
+    /**
+     * Creates the object for @a G.
+     *
+     * @param G The graph.
+     */
+    DynBetweenness(const Graph &G);
+
+    /**
+     * Runs static betweenness centrality algorithm on the initial graph.
+     */
+    void run() override;
+
+    /**
+     * Updates the betweenness centralities after an edge insertions on the graph.
+     * Notice: it works only with edge insertions.
+     *
+     * @param e The edge insertions.
+     */
+    void update(GraphEvent e) override;
+
+    /**
+     * Updates the betweenness centralities after a batch of edge insertions on the graph.
+     * Notice: it works only with edge insertions.
+     *
+     * @param batch The batch of edge insertions.
+     */
+    void updateBatch(const std::vector<GraphEvent> &batch) override;
+
+    /** Returns number of visited pairs */
+    count visPairs();
+
+    edgeweight getDistance(node u, node v);
+    edgeweight getSigma(node u, node v);
+
+    count numAffectedAPSP();
+
+    count numAffectedDep();
+
+    double getTimeDep();
+
+private:
+    void increaseScore(std::vector<bool> &affected, node y, PrioQ &Q);
+    void decreaseScore(std::vector<bool> &affected, node y, PrioQ &Q);
+    node u;
+    node v;
+    edgeweight diameter = 0.0;
+    const edgeweight infDist = std::numeric_limits<edgeweight>::max();
+    count visitedPairs = 0;
+    std::vector<std::vector<edgeweight>> distances;
+    std::vector<std::vector<edgeweight>> distancesOld;
+    // total number of shortest paths between two nodes
+    std::vector<std::vector<edgeweight>> sigma;
+    std::vector<std::vector<edgeweight>> sigmaOld;
+
+    count affectedAPSP = 0;
+    count affectedDep = 0;
+    double timeDep = 0;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_DYN_BETWEENNESS_HPP_

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

@@ -0,0 +1,98 @@
+/*
+ * DYNBETNODE.hpp
+ *
+ *  Created on: 10.03.2016
+ *      Author: Elisabetta Bergamini
+ */
+
+#ifndef NETWORKIT_CENTRALITY_DYN_BETWEENNESS_ONE_NODE_HPP_
+#define NETWORKIT_CENTRALITY_DYN_BETWEENNESS_ONE_NODE_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/base/DynAlgorithm.hpp>
+#include <networkit/dynamics/GraphEvent.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup graph
+ * This algorithm computes the betweenness centrality for a specified focus node x.
+ * It works for dynamic graphs that can be undirected/directed and unweighted/weighted without
+ * negative cycles. The Algorithm proceeds as described in [1]. The run() method computes the
+ * betweenness centrality by computing SSSP (similar to Dijkstra) for each node.
+ * The update() method only works with edge insertions and edge weight decrements and has a WC
+ * runtime complexity of O(n²) which outperforms the DynamicBetweenness algorithm for all nodes
+ * (instead of one focus node) that takes O(nm).
+ *
+ * [1] Bergamini et al. : Improving the Betweenness Centrality of a Node by Adding Links
+ *    https://dl.acm.org/doi/abs/10.1145/3166071
+ */
+
+class DynBetweennessOneNode : public Algorithm, public DynAlgorithm {
+
+public:
+    /**
+     * Creates the object for @a G.
+     *
+     * @param G The graph.
+     * @paarm x The node for which we want to compute betweenness.
+     */
+    DynBetweennessOneNode(Graph &G, node x);
+
+    /** initialize distances and Pred by repeatedly running the Dijkstra2 algorithm */
+    void run() override;
+
+    /* Computes the betweenness centrality of x by running BFS for each node */
+    void runUnweighted();
+
+    /* Computes the betweenness centrality of x by running Dijkstra for each node */
+    void runWeighted();
+
+    /**
+     * Updates the betweenness centrality of x after an edge insertions on the graph.
+     * Notice: it works only with edge insertions.
+     *
+     * @param e The edge insertions.
+     */
+    void update(GraphEvent event) override;
+
+    /**
+     * Updates the betweenness centrality of x after a batch of edge insertions on the graph.
+     * Notice: it works only with edge insertions.
+     *
+     * @param batch The batch of edge insertions.
+     */
+    void updateBatch(const std::vector<GraphEvent> &batch) override;
+
+    /** Returns the new betweenness score of node x after the insertion of an edge. Distances and
+     * scores of the other nodes are not changed by this function. */
+    edgeweight computeScore(GraphEvent event);
+
+    edgeweight getDistance(node u, node v);
+    edgeweight getSigma(node u, node v);
+    edgeweight getSigmax(node u, node v);
+    edgeweight getbcx();
+
+private:
+    Graph &G;
+    node x;
+    // betweenness centrality of node x
+    edgeweight bcx = 0;
+    const edgeweight infDist = std::numeric_limits<edgeweight>::max();
+    const edgeweight epsilon =
+        0.0000000001; // make sure that no legitimate edge weight is below that.
+
+    std::vector<std::vector<edgeweight>> distances;
+    std::vector<std::vector<edgeweight>> distancesOld;
+    // total number of shortest paths between two nodes
+    std::vector<std::vector<edgeweight>> sigma;
+    // number of shortest paths between two nodes that go through node x
+    std::vector<std::vector<edgeweight>> sigmax;
+    std::vector<std::vector<edgeweight>> sigmaxOld;
+
+    std::vector<node> Pred;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_DYN_BETWEENNESS_ONE_NODE_HPP_

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

@@ -0,0 +1,115 @@
+/*
+ * DynKatzCentrality.hpp
+ *
+ *  Created on: April 2018
+ *      Author: Alexander van der Grinten
+ *      based on code by Elisabetta Bergamini
+ */
+
+#ifndef NETWORKIT_CENTRALITY_DYN_KATZ_CENTRALITY_HPP_
+#define NETWORKIT_CENTRALITY_DYN_KATZ_CENTRALITY_HPP_
+
+#include <networkit/auxiliary/PrioQueue.hpp>
+#include <networkit/base/DynAlgorithm.hpp>
+#include <networkit/centrality/Centrality.hpp>
+#include <networkit/dynamics/GraphEvent.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Finds the top-k nodes with highest Katz centrality
+ */
+class DynKatzCentrality : public Centrality, public DynAlgorithm {
+protected:
+    double alpha; // damping
+    count k;
+    count maxdeg;
+    bool groupOnly;
+
+    // Nodes that have Katz score that only differ by this constant might appear
+    // swapped in the ranking.
+    double rankTolerance;
+
+public:
+    bool useQueue = false;
+
+public:
+    /**
+     * Constructs a DynKatzCentrality object for the given Graph @a G. The damping
+     * factor is set to 1/(maxdeg + 1), where maxdeg is the maxmum degree in the
+     * graph.
+     *
+     * @param[in] G The graph.
+     * @param[in] k The number k for which we want to find the top-k nodes with
+     * highest Katz centrality
+     * @param[in] groupOnly Set whether the update will only update top-k nodes.
+     * @param[in] tolerance The tolerance for convergence.
+     */
+    DynKatzCentrality(const Graph &G, count k, bool groupOnly = false, double tolerance = 1e-9);
+
+    void run() override;
+
+    /**
+     * Updates the katz centralities after an edge insertion or deletion on the
+     * graph.
+     *
+     * @param event The edge insertions or deletion.
+     */
+    void updateBatch(const std::vector<GraphEvent> &events) override;
+
+    void update(GraphEvent singleEvent) override {
+        std::vector<GraphEvent> events{singleEvent};
+        updateBatch(events);
+    }
+
+    node top(count n = 0) {
+        assert(activeRanking.size() > n);
+        return activeRanking[n];
+    }
+
+    /**
+     * Returns the (upper) bound of the centrality of each node
+     */
+    double bound(node v);
+
+    /**
+     * Returns true if the bounds are sharp enough to rank two nodes against each
+     * other.
+     */
+    bool areDistinguished(node u, node v);
+
+private:
+    /**
+     * Returns true if the bounds are sharp enough to rank two nodes against
+     * each other **within the tolerance**.
+     * Precondition: The first node appears higher in the current ranking the the
+     * second one.
+     */
+    bool areSufficientlyRanked(node high, node low);
+
+    /**
+     * Performs a single iteration of the algorithm.
+     */
+    void doIteration();
+
+    /**
+     * Returns true iff the ranking converged for the top-k.
+     */
+    bool checkConvergence();
+
+    std::vector<bool> isActive;
+    std::vector<node> activeRanking;
+    Aux::PrioQueue<double, node> activeQueue;
+    bool filledQueue = false;
+
+    std::vector<double> baseData;
+    std::vector<double> boundData;
+
+public: // TODO: This is public because tests access it.
+    std::vector<std::vector<count>> nPaths;
+    count levelReached = 0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_CENTRALITY_DYN_KATZ_CENTRALITY_HPP_

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

@@ -0,0 +1,223 @@
+/*
+ * DynTopHarmonicCloseness.hpp
+ *
+ *  Created on: 28.02.2018
+ *      Author: nemes, Eugenio Angriman
+ */
+
+#ifndef NETWORKIT_CENTRALITY_DYN_TOP_HARMONIC_CLOSENESS_HPP_
+#define NETWORKIT_CENTRALITY_DYN_TOP_HARMONIC_CLOSENESS_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/base/DynAlgorithm.hpp>
+#include <networkit/components/DynConnectedComponents.hpp>
+#include <networkit/components/DynWeaklyConnectedComponents.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * Manages the list of the k nodes with the highest closeness centrality in a
+ * dynamic graph.
+ *
+ * @ingroup centrality
+ */
+class DynTopHarmonicCloseness : public Algorithm, public DynAlgorithm {
+public:
+    /**
+     * Constructs the DynTopHarmonicCloseness class. This class implements dynamic
+     * algorithms for harmonic top-k closeness centrality. The implementation
+     * is based on the static algorithms by Borassi et al. (complex networks)
+     * and Bergamini et al. (large-diameter networks).
+     *
+     * @param G The graph.
+     * @param k The number of top nodes.
+     * @param useBFSbound Whether to use the algorithm for networks with large
+     * diameter
+     */
+    DynTopHarmonicCloseness(const Graph &G, count k = 1, bool useBFSbound = false);
+
+    ~DynTopHarmonicCloseness() override;
+
+    /**
+     * Computes the k most central nodes on the initial graph.
+     */
+    void run() override;
+
+    /**
+     * Returns a list with the k most central nodes.
+     * 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 k highest closeness centralities.
+     * 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);
+
+    /**
+     * Returns the ranking of the k most central nodes in the graph.
+     * 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 ranking.
+     */
+    std::vector<std::pair<node, edgeweight>> ranking(bool includeTrail = false);
+
+    void reset();
+
+    /**
+     * Updates the list of the k nodes with the highest closeness in G.
+     *
+     * @param event The edge modification event.
+     */
+    void update(GraphEvent event) override;
+
+    /**
+     * Updates the list of k nodes with the highest closeness in G
+     * after a batch of updates.
+     *
+     * @param batch A vector of edge modification events.
+     */
+    void updateBatch(const std::vector<GraphEvent> &batch) override;
+
+protected:
+    /**
+     * Runs a pruned BFS from the node @a u. The search is aborted once the
+     * closeness centrality of @a u must be smaller than @a x.
+     *
+     * @param v The start node.
+     * @param x The closeness centrality of the k-th most central node.
+     * @param n The number of nodes in the graph.
+     * @param r The number of reachable nodes (or an upper bound in directed
+     * graphs) for each node.
+     * @param visited The vector containing the visited status.
+     * @param distances The vector containing the distances.
+     * @param pred The vector containing the predecessor of each node.
+     * @param visitedEdges The number of visited edges.
+     * @return
+     */
+    std::pair<edgeweight, bool> BFScut(node v, edgeweight x, count n, count r,
+                                       std::vector<uint8_t> &visited, std::vector<count> &distances,
+                                       std::vector<node> &pred, count &visitedEdges);
+
+    /**
+     * Computes the exact closeness centrality of the node @a x and stores upper
+     * bounds for all other nodes in @a S2.
+     *
+     * @param x The start node.
+     * @param S2 The upper bounds for all other nodes.
+     * @param visEdges The number of visited edges.
+     */
+    void BFSbound(node x, std::vector<double> &S2, count *visEdges);
+
+    /**
+     * Handles an edge insertion.
+     *
+     * @param event The graph event.
+     */
+    void addEdge(const GraphEvent &event);
+
+    /**
+     * Handles an edge removal.
+     *
+     * @param event The graph event.
+     */
+    void removeEdge(const GraphEvent &event);
+
+    /**
+     * Computes the number of reachable nodes or an upper bound in directed
+     * graphs.
+     */
+    void computeReachableNodes();
+    /**
+     * Computes an upper bound for the number of reachable nodes for each node
+     * in a directed graph.
+     */
+    void computeReachableNodesDirected();
+    /**
+     * Computes the number of reachable nodes in an undirected graph.
+     */
+    void computeReachableNodesUndirected();
+
+    /**
+     * Recomputes the number of reachable nodes in an undirected graph after
+     * inserting an edge between @a u and @a v.
+     * @param u The first node.
+     * @param v The second node.
+     */
+    void updateReachableNodesAfterInsertion(node u, node v);
+
+    /**
+     * Recomputes the number of reachable nodes in an undirected graph after
+     * removing an edge between @a u and @a v.
+     * @param u The first node.
+     * @param v The second node.
+     */
+    void updateReachableNodesAfterDeletion(const GraphEvent &event);
+
+    void init();
+
+    const Graph &G;
+    count n;
+    count k;
+    bool useBFSbound;
+    count trail;
+    double minCloseness;
+    count nMinCloseness;
+    std::vector<node> topk;
+    std::vector<edgeweight> topkScores;
+    std::vector<edgeweight> allScores;
+    std::vector<uint8_t> isExact;
+    std::vector<uint8_t> isValid;
+    std::vector<edgeweight> cutOff;
+    std::vector<uint8_t> exactCutOff;
+    DynConnectedComponents *comps;
+    bool hasComps = false;
+    Partition component;
+    DynWeaklyConnectedComponents *wComps;
+    bool hasWComps = false;
+    std::vector<count> r;
+    std::vector<count> rOld;
+    std::vector<count> reachL;
+};
+
+inline std::vector<node> DynTopHarmonicCloseness::topkNodesList(bool includeTrail) {
+    assureFinished();
+    if (!includeTrail) {
+        auto begin = topk.begin();
+        std::vector<node> topkNoTrail(begin, begin + k);
+        return topkNoTrail;
+    }
+    return topk;
+}
+
+inline std::vector<edgeweight> DynTopHarmonicCloseness::topkScoresList(bool includeTrail) {
+    assureFinished();
+    if (!includeTrail) {
+        auto begin = topkScores.begin();
+        std::vector<edgeweight> topkScoresNoTrail(begin, begin + k);
+        return topkScoresNoTrail;
+    }
+    return topkScores;
+}
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_CENTRALITY_DYN_TOP_HARMONIC_CLOSENESS_HPP_

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

@@ -0,0 +1,41 @@
+/*
+ * EigenvectorCentrality.hpp
+ *
+ *  Created on: 19.03.2014
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_CENTRALITY_EIGENVECTOR_CENTRALITY_HPP_
+#define NETWORKIT_CENTRALITY_EIGENVECTOR_CENTRALITY_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Computes the leading eigenvector of the graph's adjacency matrix (normalized in 2-norm).
+ * Interpreted as eigenvector centrality score.
+ */
+class EigenvectorCentrality final : public Centrality {
+    const double tol; // error tolerance
+
+public:
+    /**
+     * Constructs an EigenvectorCentrality object for the given Graph @a G. @a tol defines the
+     * tolerance for convergence.
+     *
+     * @param[in] G The graph.
+     * @param[in] tol The tolerance for convergence.
+     * TODO running time
+     */
+    EigenvectorCentrality(const Graph &G, double tol = 1e-8);
+
+    /**
+     * Computes eigenvector centrality on the graph passed in constructor.
+     */
+    void run() override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_CENTRALITY_EIGENVECTOR_CENTRALITY_HPP_

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

@@ -0,0 +1,51 @@
+/*
+ *  EstimateBetweenness.hpp
+ *
+ *  Created on: 13.06.2014
+ *      Author: Christian Staudt, Elisabetta Bergamini
+ */
+
+#ifndef NETWORKIT_CENTRALITY_ESTIMATE_BETWEENNESS_HPP_
+#define NETWORKIT_CENTRALITY_ESTIMATE_BETWEENNESS_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Estimation of betweenness centrality according to algorithm described in
+ * Sanders, Geisberger, Schultes: Better Approximation of Betweenness Centrality.
+ * There is no proven theoretical guarantee on the quality of the approximation. However, the
+ * algorithm was shown to perform well in practice. If a guarantee is required, use
+ * ApproxBetweenness.
+ */
+class EstimateBetweenness : public Centrality {
+
+public:
+    /**
+     * The algorithm estimates the betweenness of all nodes, using weighting
+     * of the contributions to avoid biased estimation. The run() method takes O(m)
+     * time per sample, where  m is the number of edges of the graph.
+     *
+     * @param	graph		input graph
+     * @param	nSamples	 user defined number of samples
+     * @param	normalized   normalize centrality values in interval [0,1] ?
+     * @param	parallel_flag	if true, run in parallel with additional memory cost z + 3z * t
+     */
+    EstimateBetweenness(const Graph &G, count nSamples, bool normalized = false,
+                        bool parallel_flag = false);
+
+    /**
+     * Computes betweenness estimation on the graph passed in constructor.
+     */
+    void run() override;
+
+private:
+    count nSamples;
+    bool parallel_flag;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_ESTIMATE_BETWEENNESS_HPP_