@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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

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

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