@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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

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

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