@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,98 @@
+/*
+ * Centrality.hpp
+ *
+ *  Created on: 19.02.2014
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_CENTRALITY_CENTRALITY_HPP_
+#define NETWORKIT_CENTRALITY_CENTRALITY_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Abstract base class for centrality measures.
+ */
+class Centrality : public Algorithm {
+public:
+    /**
+     * Constructs the Centrality class for the given Graph @a G. If the centrality scores should be
+     * normalized, then set @a normalized to @c true.
+     *
+     * @param G The graph.
+     * @param normalized If set to @c true the scores are normalized in the interval [0,1].
+     * @param computeEdgeCentrality		If true, compute also edge centralities (for algorithms
+     * where this is applicable)
+     */
+    Centrality(const Graph &G, bool normalized = false, bool computeEdgeCentrality = false);
+
+    /**
+     * Computes centrality scores on the graph passed in constructor.
+     */
+    void run() override = 0;
+
+    /**
+     * Get a vector containing the centrality score for each node in the graph.
+     *
+     * @return The centrality scores calculated by @ref run().
+     */
+    virtual const std::vector<double> &scores() const;
+
+    /**
+     * Get a vector containing the edge centrality score for each edge in the graph (where
+     * applicable).
+     * @return The edge betweenness scores calculated by @ref run().
+     */
+    virtual std::vector<double> edgeScores();
+
+    /**
+     * Get a vector of pairs sorted into descending order. Each pair contains a node and the
+     * corresponding score calculated by @ref run().
+     * @return A vector of pairs.
+     */
+    virtual std::vector<std::pair<node, double>> ranking();
+
+    /**
+     * Get the centrality score of node @a v calculated by @ref run().
+     *
+     * @param v A node.
+     * @return The betweenness score of node @a v.
+     */
+    virtual double score(node v);
+
+    /**
+     * Get the theoretical maximum of centrality score in the given graph.
+     *
+     * @return The maximum centrality score.
+     */
+    virtual double maximum();
+
+    /**
+     * Compute the centralization of a network with respect to some centrality measure.
+
+     * The centralization of any network is a measure of how central its most central
+     * node is in relation to how central all the other nodes are.
+     * Centralization measures then (a) calculate the sum in differences
+     * in centrality between the most central node in a network and all other nodes;
+     * and (b) divide this quantity by the theoretically largest such sum of
+     * differences in any network of the same size.
+
+     * @return centrality index
+     */
+    virtual double centralization();
+
+protected:
+    const Graph &G;
+    std::vector<double> scoreData;
+    std::vector<double> edgeScoreData;
+    bool normalized; // true if scores should be normalized in the interval [0,1]
+    bool computeEdgeCentrality;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_CENTRALITY_HPP_

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

@@ -0,0 +1,107 @@
+/*
+ * Closeness.hpp
+ *
+ *  Created on: 03.10.2014
+ *     Authors: nemes,
+ *              Eugenio Angriman <angrimae@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_CENTRALITY_CLOSENESS_HPP_
+#define NETWORKIT_CENTRALITY_CLOSENESS_HPP_
+
+#include <networkit/auxiliary/VectorComparator.hpp>
+#include <networkit/centrality/Centrality.hpp>
+
+#include <tlx/container/d_ary_addressable_int_heap.hpp>
+
+namespace NetworKit {
+
+enum ClosenessVariant {
+    STANDARD = 0,
+    GENERALIZED = 1,
+    standard = STANDARD, // this + following added for backwards compatibility
+    generalized = GENERALIZED
+};
+
+/**
+ * @ingroup centrality
+ */
+class Closeness : public Centrality {
+
+public:
+    /**
+     * Constructs the Closeness class for the given Graph @a G. If the closeness
+     * 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. NOTICE: the graph has to be
+     * connected.
+     *
+     * @param G The graph.
+     * @param normalized Set this parameter to <code>false</code> if scores
+     * should not be normalized into an interval of [0, 1]. Normalization only
+     * for unweighted graphs.
+     *
+     */
+    Closeness(const Graph &G, bool normalized,
+              ClosenessVariant variant = ClosenessVariant::STANDARD);
+
+    /**
+     * Old constructor, we keep it for backward compatibility. It computes the
+     * standard variant of the closenes.
+     *
+     * @param G The graph.
+     * @param normalized Set this parameter to <code>false</code> if scores
+     * should not be normalized into an interval of [0, 1]. Normalization only
+     * for unweighted graphs.
+     * @param checkConnectedness turn this off if you know the graph is
+     * connected.
+     *
+     */
+    Closeness(const Graph &G, bool normalized = true, bool checkConnectedness = true);
+
+    /**
+     * Computes closeness cetrality 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 normalized ? 1. : (1. / (static_cast<double>(G.upperNodeIdBound() - 1)));
+    }
+
+private:
+    ClosenessVariant variant;
+    std::vector<std::vector<count>> uDist;
+    std::vector<std::vector<double>> dDist;
+    std::vector<std::vector<uint8_t>> visited;
+    std::vector<uint8_t> ts;
+
+    void checkConnectedComponents() const;
+    void bfs();
+    void dijkstra();
+    void incTS();
+    void updateScoreData(node u, count reached, double sum) {
+        if (sum > 0) {
+            if (variant == ClosenessVariant::STANDARD) {
+                scoreData[u] = 1.0 / sum;
+            } else {
+                scoreData[u] = static_cast<double>(reached - 1) / sum
+                               / static_cast<double>(G.numberOfNodes() - 1);
+            }
+        } else {
+            scoreData[u] = 0.;
+        }
+        if (normalized)
+            scoreData[u] *=
+                (variant == ClosenessVariant::STANDARD ? G.numberOfNodes() : reached) - 1.;
+    }
+
+    std::vector<tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<double>>> heaps;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_CLOSENESS_HPP_

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

@@ -0,0 +1,113 @@
+/*
+ *  ComplexPaths.hpp
+ *
+ *
+ *  Created on:16.06.2023
+ *      Author: Klaus Ahrens
+ *              <ahrens@informatik.hu-berlin.de>
+ *
+ *  adapted and reimplemented from
+ *
+ *            https://github.com/drguilbe/complexpaths.git
+ *
+ *  see [ Guilbeault, D., Centola, D. Topological measures for
+ *        identifying and predicting the spread of complex contagions.
+ *        Nat Commun 12, 4430 (2021).
+ *        https://doi.org/10.1038/s41467-021-24704-6 ]
+ *
+ */
+
+#ifndef NETWORKIT_CENTRALITY_COMPLEX_PATHS_HPP_
+#define NETWORKIT_CENTRALITY_COMPLEX_PATHS_HPP_
+
+#include <random>
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * computes
+ *      in Mode::singleNode :
+ *	complex path graphs (with inner connection degree above threshold)
+ *	from a start node in Mode::singleNode
+ *	OR
+ *      in Mode::allNodes :
+ *	complex path lengths (maximal distance in complex path graphs for
+ *	starting nodes u) for all nodes u
+ *
+ */
+
+class ComplexPathAlgorithm : public Algorithm {
+public:
+    /**
+     * operation modes
+     */
+    enum Mode { singleNode, allNodes };
+
+    /**
+     * Constructs the ComplexPathAlgorithm class for the given Graph @a G.
+     * depending on the @a mode the algorithm the algorithm
+     *   in @a mode <code>Mode::singleNode</code> starting from @a start
+     *      constructs a subgraph of @a G in which all inner nodes have
+     *      more than @a threshold neighbors
+     *      call <code>getComplexGraph</code> after run to get it
+     *   in @a mode <code>Mode::allNodes</code> constructs these subgraphs for all nodes
+     *      and calculates their longest paths from their start nodes
+     *      these length can be absolute or normalized to [0..1] by calling
+     *      normalize before or after <code>run</code>
+     *      call <code>getPLci</code> after run to get these lengths
+     *
+     * @param G The graph.
+     * @param threshold number of neighbors needed
+     * @param mode as explained above
+     * @param start start node for Mode::singleNode
+     */
+    ComplexPathAlgorithm(const Graph &G, count threshold = 3, Mode mode = Mode::allNodes,
+                         node start = none);
+
+    /**
+     * normalize path lengths
+     */
+    void normalize();
+
+    void run() override;
+
+    /**
+     * [normalized] results after running in <code>Mode::allNodes</code>
+     */
+    std::vector<double> getPLci();
+
+    /**
+     * resulting graph after running in <code>Mode::singleNode</code>
+     */
+    GraphW getComplexGraph();
+
+    /**
+     * nodes in the resulting graph after running in <code>Mode::singleNode</code>
+     * which are connected to start by at least threshold paths
+     */
+    std::vector<node> getAdopters();
+
+private:
+    const Graph *inputGraph;
+    GraphW complexPathGraph;
+    std::vector<double> complexPathsLengths;
+    std::vector<node> adopters;
+    const Mode mode;
+    const node start;
+    const count threshold;
+    bool normPaths;
+
+    GraphW complexPathsGraph(node seed, count threshold, std::vector<node> *adopters);
+    std::vector<double> complexPathLength(count t);
+    std::vector<node> generateSeeds(node seed, const Graph &g, count threshold);
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_COMPLEX_PATHS_HPP_

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

@@ -0,0 +1,161 @@
+/*
+ * CoreDecomposition.hpp
+ *
+ *  Created on: Oct 28, 2013
+ *      Author: Lukas Barth, David Weiss, Christian Staudt
+ */
+
+#ifndef NETWORKIT_CENTRALITY_CORE_DECOMPOSITION_HPP_
+#define NETWORKIT_CENTRALITY_CORE_DECOMPOSITION_HPP_
+
+#include <list>
+#include <string>
+#include <vector>
+
+#include <networkit/centrality/Centrality.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Cover.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Computes k-core decomposition of a graph.
+ */
+class CoreDecomposition : public Centrality {
+
+public:
+    /**
+     * Create CoreDecomposition class for graph @a G. The graph may not contain self-loops.
+     *
+     * Contains the parallel algorithm by
+     * Dasari, N.S.; Desh, R.; Zubair, M., "ParK: An efficient algorithm for k-core decomposition on
+     * multicore processors," in Big Data (Big Data), * 2014 IEEE International Conference.
+     *
+     * TODO complexity?
+     * @param G The graph.
+     * @param normalized If set to @c true the scores are normalized in the interval [0,1].
+     * @param enforceBucketQueueAlgorithm If set to @c true, uses a bucket priority queue data
+     * structure. This it is generally slower than ParK but may be more flexible. TODO check
+     * @param storeNodeOrder If set to @c true, the order of the nodes in ascending order of the
+     * cores is stored and can later be returned using getNodeOrder(). Enforces the sequential
+     * bucket priority queue algorithm.
+     *
+     * The algorithm runs in parallel if the usage of a bucket priority queue is not enforced and
+     * if the node ids of the input graph are continuous (i.e., numberOfNodes() =
+     * upperNodeIdBound()).
+     */
+    CoreDecomposition(const Graph &G, bool normalized = false,
+                      bool enforceBucketQueueAlgorithm = false, bool storeNodeOrder = false);
+
+    /**
+     * Perform k-core decomposition of graph passed in constructor.
+     */
+    void run() override;
+
+    /**
+     * Get the k-cores as a graph cover object.
+     *
+     * @return the k-cores as a Cover
+     */
+    Cover getCover() const;
+
+    /**
+     * Get the k-shells as a partition object
+     *
+     * @return the k-shells as a Partition
+     */
+    Partition getPartition() const;
+
+    /**
+     * Get maximum core number.
+     *
+     * @return The maximum core number
+     */
+    index maxCoreNumber() const;
+
+    /**
+     * Get the theoretical maximum of centrality score in the given graph.
+     *
+     * @return The theoretical maximum centrality score.
+     */
+    double maximum() override;
+
+    /**
+     * Get the node order.
+     *
+     * This is only possible when storeNodeOrder was set.
+     *
+     * @return The nodes sorted by increasing core number.
+     */
+    const std::vector<node> &getNodeOrder() const;
+
+private:
+    index maxCore; // maximum core number of any node in the graph
+
+    bool enforceBucketQueueAlgorithm; // in case one wants to switch to the alternative algorithm
+
+    bool canRunInParallel; // signifies if a parallel algorithm can be used
+
+    bool storeNodeOrder; // signifies if the node order shall be stored
+
+    std::vector<node> nodeOrder; // Stores the node order, i.e., all nodes sorted by core number
+
+    /**
+     * Perform k-core decomposition of graph passed in constructor.
+     * ParK is an algorithm by Naga Shailaja Dasari, Ranjan Desh, and Zubair M.
+     * See http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7004366 for details.
+     */
+    void runWithParK();
+
+    /**
+     * Perform k-core decomposition of graph passed in constructor.
+     * The algorithm is based on a bucket priority queue data structure.
+     * It is generally slower than ParK but may be more flexible.
+     */
+    void runWithBucketQueues();
+
+    /**
+     * Determines nodes whose remaining degree equals @a level.
+     * @param[in] level Shell number (= level) currently processed.
+     * @param[in] degrees Remaining degree for each node.
+     * @param[inout] curr Nodes to be processed in current level.
+     */
+    void scan(index level, const std::vector<count> &degrees, std::vector<node> &curr);
+
+    /**
+     * Determines in parallel the nodes whose remaining degree equals @a level.
+     * @param[in] level Shell number (= level) currently processed.
+     * @param[in] degrees Remaining degree for each node.
+     * @param[inout] curr Nodes to be processed in current level.
+     */
+    void scanParallel(index level, const std::vector<count> &degrees, std::vector<node> &curr,
+                      std::vector<char> &active);
+
+    /**
+     * Processes nodes (and their neighbors) identified by previous scan.
+     * @param[in] level Shell number (= level) currently processed.
+     * @param[inout] degrees Remaining degree for each node.
+     * @param[in] curr Nodes to be processed in this call.
+     * @param[inout] next Nodes to be processed next in current level (certain neighbors of nodes in
+     * curr).
+     */
+    void processSublevel(index level, std::vector<count> &degrees, const std::vector<node> &curr,
+                         std::vector<node> &next);
+
+    /**
+     * Processes in parallel nodes (and their neighbors) identified by previous scan.
+     * @param[in] level Shell number (= level) currently processed.
+     * @param[inout] degrees Remaining degree for each node.
+     * @param[in] curr Nodes to be processed in this call.
+     * @param[inout] next Nodes to be processed next in current level (certain neighbors of nodes in
+     * curr).
+     */
+    void processSublevelParallel(index level, std::vector<count> &degrees,
+                                 const std::vector<node> &curr, std::vector<node> &next,
+                                 std::vector<char> &active);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_CENTRALITY_CORE_DECOMPOSITION_HPP_

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

@@ -0,0 +1,55 @@
+/*
+ * DegreeCentrality.hpp
+ *
+ *  Created on: 19.02.2014
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_CENTRALITY_DEGREE_CENTRALITY_HPP_
+#define NETWORKIT_CENTRALITY_DEGREE_CENTRALITY_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Node centrality index which ranks nodes by their degree.
+ * Optional normalization by maximum degree.
+ */
+class DegreeCentrality : public Centrality {
+public:
+    /**
+     * Constructs the DegreeCentrality class for the given Graph @a G. If the centrality scores
+     * should be normalized, then set @a normalized to <code>true</code>. run() runs in O(n) time if
+     * ignoreSelfLoops is false or the graph has no self-loops; otherwise it runs in O(m).
+     *
+     * @param G The graph.
+     * @param normalized Set this parameter to <code>true</code> if scores should be normalized in
+     * the interval [0,1].
+     * @param outDeg If set to <code>true</code>, computes the centrality based on the out-degrees,
+     * otherwise based on the in-degrees.
+     * @param ignoreSelfLoops If set to <code>true</code>, self loops will not be taken into
+     * account.
+     */
+    DegreeCentrality(const Graph &G, bool normalized = false, bool outDeg = true,
+                     bool ignoreSelfLoops = true);
+
+    /**
+     * Computes degree centraity on the graph passed in constructor.
+     */
+    void run() override;
+
+    /**
+     * @return the theoretical maximum degree centrality, which is $n$ (including the possibility of
+     * a self-loop)
+     */
+    double maximum() override;
+
+private:
+    bool outDeg, ignoreSelfLoops;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_DEGREE_CENTRALITY_HPP_

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

@@ -0,0 +1,95 @@
+/*
+ * DynApproxBetweenness.hpp
+ *
+ *  Created on: 31.07.2014
+ *      Author: ebergamini
+ */
+
+#ifndef NETWORKIT_CENTRALITY_DYN_APPROX_BETWEENNESS_HPP_
+#define NETWORKIT_CENTRALITY_DYN_APPROX_BETWEENNESS_HPP_
+
+#include <networkit/base/DynAlgorithm.hpp>
+#include <networkit/centrality/Centrality.hpp>
+#include <networkit/components/StronglyConnectedComponents.hpp>
+#include <networkit/distance/DynSSSP.hpp>
+#include <networkit/dynamics/GraphEvent.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+#include <omp.h>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Interface for dynamic approximated betweenness centrality algorithm.
+ */
+class DynApproxBetweenness : public Centrality, public DynAlgorithm {
+
+public:
+    /**
+     * Implementation from the algorithm from "Approximating Betweenness Centrality in Fully-dynamic
+     * Networks" from Internet Mathematics vol. 5 by Elisabetta Bergamini and Henning Meyerhenke
+     * 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.
+     *
+     * @param	G			the graph
+     * @param  storePredecessors   keep track of the lists of predecessors?
+     * @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 0.5 by default.
+     */
+    DynApproxBetweenness(const Graph &G, double epsilon = 0.01, double delta = 0.1,
+                         bool storePredecessors = true, double universalConstant = 0.5);
+
+    /**
+     * Runs the static approximated betweenness centrality algorithm on the initial graph.
+     */
+    void run() override;
+
+    /**
+     * Updates the betweenness centralities after an edge insertions on the graph.
+     *
+     * @param e The edge insertion or deletion.
+     */
+    void update(GraphEvent e) override;
+
+    /**
+     * Updates the betweenness centralities after a batch of edge insertions on the graph.
+     *
+     * @param batch The batch of edge insertions and/or deletions.
+     */
+    void updateBatch(const std::vector<GraphEvent> &batch) override;
+
+    /**
+     * Get number of path samples used for last calculation
+     */
+    count getNumberOfSamples() const noexcept;
+
+private:
+    void sampleNewPaths(count start, count end);
+    double epsilon; //!< maximum error
+    double delta;
+    bool storePreds;
+    const double universalConstant;
+    count r;
+    std::vector<std::unique_ptr<DynSSSP>> sssp;
+    std::vector<std::vector<count>> npaths;
+
+    std::vector<node> u;
+    std::vector<node> v;
+    std::vector<std::vector<node>> sampledPaths;
+
+    static constexpr edgeweight infDist = std::numeric_limits<edgeweight>::max();
+
+    std::vector<node> sortComponentsTopologically(GraphW &sccDAG, StronglyConnectedComponents &scc);
+
+    count computeVDdirected();
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_DYN_APPROX_BETWEENNESS_HPP_