@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,62 @@
+/*
+ * KatzCentrality.hpp
+ *
+ *  Created on: 09.01.2015
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_CENTRALITY_KATZ_CENTRALITY_HPP_
+#define NETWORKIT_CENTRALITY_KATZ_CENTRALITY_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+enum EdgeDirection : char {
+    IN_EDGES = 0,
+    OUT_EDGES = 1,
+    InEdges = IN_EDGES, // this + following added for backwards compatibility
+    OutEdges = OUT_EDGES
+};
+
+/**
+ * @ingroup centrality
+ * Computes the Katz centrality of the graph.
+ * NOTE: There is an inconsistency in the definition in Newman's book (Ch. 7) regarding
+ * directed graphs; we follow the verbal description, which requires to sum over the incoming
+ * edges (as opposed to outgoing ones).
+ */
+class KatzCentrality : public Centrality {
+    std::vector<double> values;
+
+protected:
+    const double alpha; // damping
+    const double beta;  // constant centrality amount
+    const double tol;   // error tolerance
+    static double defaultAlpha(const Graph &G);
+
+public:
+    /**
+     * Constructs a KatzCentrality object for the given Graph @a G. @a tol defines the tolerance for
+     * convergence. Each iteration of the algorithm requires O(m) time. The number of iterations
+     * depends on how long it takes to reach the convergence.
+     *
+     * @param[in] G The graph.
+     * @param[in] alpha Damping of the matrix vector product result, must be non negative.
+     * Leave this parameter to 0 to use the default value 1 / (max_degree + 1).
+     * @param[in] beta Constant value added to the centrality of each vertex
+     * @param[in] tol The tolerance for convergence.
+     */
+    KatzCentrality(const Graph &G, double alpha = 0, double beta = 0.1, double tol = 1e-8);
+
+    /**
+     * Computes katz centrality on the graph passed in constructor.
+     */
+    void run() override;
+
+    // Whether to count in-edges or out-edges
+    EdgeDirection edgeDirection = EdgeDirection::IN_EDGES;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_CENTRALITY_KATZ_CENTRALITY_HPP_

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

@@ -0,0 +1,44 @@
+/*
+ * LaplacianCentrality.hpp
+ *
+ *  Created on: 08.03.2018
+ *      Author: Kolja Esders
+ */
+
+#ifndef NETWORKIT_CENTRALITY_LAPLACIAN_CENTRALITY_HPP_
+#define NETWORKIT_CENTRALITY_LAPLACIAN_CENTRALITY_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Computes the Laplacian centrality of the graph.
+ *
+ * The implementation is a simplification of the original algorithm proposed by Qi et al. in
+ * "Laplacian centrality: A new centrality measure for weighted networks".
+ *
+ * See https://dl.acm.org/citation.cfm?id=2181343.2181780 for details.
+ */
+class LaplacianCentrality : public Centrality {
+public:
+    /**
+     * Constructs a LaplacianCentrality object for the given Graph @a G.
+     *
+     * @param G The graph.
+     * @param normalized Whether scores should be normalized by the energy of the full graph.
+     */
+    LaplacianCentrality(const Graph &G, bool normalized = false);
+
+    /**
+     * Computes the Laplacian centrality on the graph passed in the constructor.
+     *
+     * See https://dl.acm.org/citation.cfm?id=2181343.2181780 for more details about
+     * Laplacian centrality.
+     */
+    void run() override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_CENTRALITY_LAPLACIAN_CENTRALITY_HPP_

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

@@ -0,0 +1,60 @@
+/*
+ * LocalClusteringCoefficient.hpp
+ *
+ *  Created on: 31.03.2015
+ *      Author: maxv
+ */
+
+#ifndef NETWORKIT_CENTRALITY_LOCAL_CLUSTERING_COEFFICIENT_HPP_
+#define NETWORKIT_CENTRALITY_LOCAL_CLUSTERING_COEFFICIENT_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class LocalClusteringCoefficient : public Centrality {
+public:
+    /**
+     * Constructs the LocalClusteringCoefficient class for the given Graph @a G. If the local
+     * clustering coefficient scores should be normalized, then set @a normalized to
+     * <code>true</code>. The graph may not contain self-loops.
+     *
+     * There are two algorithms available. The trivial (parallel) algorithm needs only a small
+     * amount of additional memory. The turbo mode adds a (sequential, but fast) pre-processing step
+     * using ideas from [0]. This reduces the running time significantly for most graphs. However,
+     * the turbo mode needs O(m) additional memory. In practice this should be a bit less than half
+     * of the memory that is needed for the graph itself. The turbo mode is particularly effective
+     * for graphs with nodes of very high degree and a very skewed degree distribution.
+     *
+     * [0] Triangle Listing Algorithms: Back from the Diversion
+     * Mark Ortmann and Ulrik Brandes * 2014 Proceedings of the Sixteenth Workshop on Algorithm
+     * Engineering and Experiments (ALENEX). 2014, 1-8
+     *
+     * @param G The graph.
+     * @param turbo If the turbo mode shall be activated.
+     * TODO running time
+     */
+    LocalClusteringCoefficient(const Graph &G, bool turbo = false);
+
+    /**
+     * Computes the local clustering coefficient on the graph passed in constructor.
+     */
+    void run() override;
+
+    /**
+     * Get the theoretical maximum of centrality score in the given graph.
+     *
+     * @return The maximum centrality score.
+     */
+    double maximum() override;
+
+protected:
+    bool turbo;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_LOCAL_CLUSTERING_COEFFICIENT_HPP_

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

@@ -0,0 +1,43 @@
+#ifndef NETWORKIT_CENTRALITY_LOCAL_PARTITION_COVERAGE_HPP_
+#define NETWORKIT_CENTRALITY_LOCAL_PARTITION_COVERAGE_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * The local partition coverage is the amount of neighbors of a node u that are in the same
+ * partition as u.
+ */
+class LocalPartitionCoverage : public Centrality {
+public:
+    /**
+     * Construct the local partition coverage instance. The running time of the run() method is
+     * O(m), where m is the number of edges in the graph.
+     *
+     * @param G The graph to use
+     * @param P The partition for which the coverage shall be calculated.
+     */
+    LocalPartitionCoverage(const Graph &G, const Partition &P);
+
+    /**
+     * Computes local partition coverage on the graph passed in constructor.
+     * This method runs in parallel.
+     */
+    void run() override;
+
+    /**
+     * Get the maximum value (1.0)
+     *
+     * @return 1.0
+     */
+    double maximum() override;
+
+protected:
+    const Partition &P;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_CENTRALITY_LOCAL_PARTITION_COVERAGE_HPP_

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

@@ -0,0 +1,42 @@
+/*
+ * LocalSquareClusteringCoefficient.hpp
+ *
+ *  Created on: 07.04.2022
+ *      Author: tillahoffmann
+ */
+
+#ifndef NETWORKIT_CENTRALITY_LOCAL_SQUARE_CLUSTERING_COEFFICIENT_HPP_
+#define NETWORKIT_CENTRALITY_LOCAL_SQUARE_CLUSTERING_COEFFICIENT_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class LocalSquareClusteringCoefficient : public Centrality {
+public:
+    /**
+     * Constructs the LocalSquareClusteringCoefficient class for the given Graph @a G.
+     *
+     * @param G The graph.
+     */
+    LocalSquareClusteringCoefficient(const Graph &G);
+
+    /**
+     * Computes the local clustering coefficient on the graph passed in constructor.
+     */
+    void run() override;
+
+    /**
+     * Get the theoretical maximum of centrality score in the given graph.
+     *
+     * @return The maximum centrality score.
+     */
+    double maximum() override;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_LOCAL_SQUARE_CLUSTERING_COEFFICIENT_HPP_

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

@@ -0,0 +1,101 @@
+/*
+ * PageRank.h
+ *
+ *  Created on: 19.03.2014
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_CENTRALITY_PAGE_RANK_HPP_
+#define NETWORKIT_CENTRALITY_PAGE_RANK_HPP_
+
+#include <atomic>
+#include <limits>
+#include <memory>
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Compute PageRank as node centrality measure. In the default mode this computation is in line
+ * with the original paper "The PageRank citation ranking: Bringing order to the web." by L. Brin et
+ * al (1999). In later publications ("PageRank revisited." by M. Brinkmeyer et al. (2005) amongst
+ * others) sink-node handling was added for directed graphs in order to comply with the theoretical
+ * assumptions by the underlying Markov chain model. This can be activated by setting the matching
+ * parameter to true. By default this is disabled, since it is an addition to the original
+ * definition.
+ *
+ * Page-Rank values can also be normalized by post-processed according to "Comparing Apples and
+ * Oranges: Normalized PageRank for Evolving Graphs" by Berberich et al. (2007). This decouples
+ * the PageRank values from the size of the input graph. To enable this, set the matching parameter
+ * to true. Note that sink-node handling is automatically activated if normalization is used.
+ *
+ * NOTE: There is an inconsistency in the definition in Newman's book (Ch. 7) regarding
+ * directed graphs; we follow the verbal description, which requires to sum over the incoming
+ * edges (as opposed to outgoing ones).
+ */
+class PageRank final : public Centrality {
+
+public:
+    enum Norm {
+        L1_NORM,
+        L2_NORM,
+        L1Norm = L1_NORM, // this + following added for backwards compatibility
+        L2Norm = L2_NORM
+    };
+
+    enum SinkHandling { NO_SINK_HANDLING, DISTRIBUTE_SINKS };
+
+    /**
+     * Constructs the PageRank class for the Graph @a G
+     *
+     * @param[in] G Graph to be processed.
+     * @param[in] damp Damping factor of the PageRank algorithm.
+     * @param[in] tol Error tolerance for PageRank iteration.
+     * @param[in] distributeSinks Set to distribute PageRank values for sink nodes. (default =
+     * false)
+     * @param[in] normalized Set to normalize Page-Rank values in order to decouple it from the
+     * network size. (default = false)
+     */
+    PageRank(const Graph &G, double damp = 0.85, double tol = 1e-8, bool normalized = false,
+             SinkHandling distributeSinks = SinkHandling::NO_SINK_HANDLING);
+
+    /**
+     * Computes page rank on the graph passed in constructor.
+     */
+    void run() override;
+
+    /**
+     * Returns the maximum PageRank score
+     */
+    double maximum() override;
+
+    /**
+     * Return the number of iterations performed by the algorithm.
+     *
+     * @return Number of iterations performed by the algorithm.
+     */
+    count numberOfIterations() const {
+        assureFinished();
+        return iterations;
+    }
+
+    // Maximum number of iterations allowed
+    count maxIterations = std::numeric_limits<count>::max();
+
+    // Norm used as stopping criterion
+    Norm norm = Norm::L2_NORM;
+
+private:
+    double damp;
+    double tol;
+    count iterations;
+    bool normalized;
+    SinkHandling distributeSinks;
+    std::atomic<double> max;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_PAGE_RANK_HPP_

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

@@ -0,0 +1,48 @@
+#ifndef NETWORKIT_CENTRALITY_PERMANENCE_CENTRALITY_HPP_
+#define NETWORKIT_CENTRALITY_PERMANENCE_CENTRALITY_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Permanence centrality measures how well a vertex belongs to its community.
+ */
+class PermanenceCentrality : public Algorithm {
+public:
+    /**
+     * Constructs the PermanenceCentrality class for the given Graph @a G and Partition @a P.
+     *
+     * @param G The input graph.
+     * @param P Partition for graph G.
+     */
+    PermanenceCentrality(const Graph &G, const Partition &P);
+    void run() override;
+
+    /**
+     * Returns the permanence centrality of node @a u.
+     *
+     * @param u Node in the input graph.
+     */
+    double getPermanence(node u);
+
+    /**
+     * Returns the intra-clustering coefficient of node @a u.
+     *
+     * @param u Node in the input graph.
+     */
+    double getIntraClustering(node u);
+
+private:
+    const Graph &G;
+    const Partition &P;
+    std::vector<index> inBegin;
+    std::vector<node> inEdges;
+    std::vector<bool> marker;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_CENTRALITY_PERMANENCE_CENTRALITY_HPP_

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

@@ -0,0 +1,45 @@
+/*
+ * Sfigality.hpp
+ *
+ *  Created on: 20.01.2016
+ *      Author:Christian Staudt
+ */
+
+#ifndef NETWORKIT_CENTRALITY_SFIGALITY_HPP_
+#define NETWORKIT_CENTRALITY_SFIGALITY_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * The sfigality of a node is the ratio of neighboring nodes that have
+ * a higher degree than the node itself.
+ */
+class Sfigality : public Centrality {
+public:
+    /**
+     * Constructs the Sfigality class for the given Graph @a G. Sfigality is a new type of
+     * node centrality measures that is high if neighboring nodes have a higher degree, e.g. in
+     social networks, if your friends have more friends than you. Formally:
+     *
+     * $$\\sigma(u) = \\frac{| \\{ v: \\{u,v\\} \\in E, deg(u) < deg(v) \\} |}{ deg(u) }$$
+     *
+     * @param G The graph.
+
+     */
+    Sfigality(const Graph &G);
+
+    void run() override;
+
+    /**
+     * Returns the node that has the most neighbours with a higher degree than itself (max
+     * Sfigality).
+     */
+    double maximum() override;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_SFIGALITY_HPP_

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

@@ -0,0 +1,86 @@
+/*
+ * SpanningEdgeCentrality.hpp
+ *
+ *  Created on: 29.07.2015
+ *      Author: henningm
+ */
+
+#ifndef NETWORKIT_CENTRALITY_SPANNING_EDGE_CENTRALITY_HPP_
+#define NETWORKIT_CENTRALITY_SPANNING_EDGE_CENTRALITY_HPP_
+
+#include <networkit/algebraic/CSRMatrix.hpp>
+#include <networkit/centrality/Centrality.hpp>
+#include <networkit/numerics/LAMG/Lamg.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ *
+ * SpanningEdgeCentrality edge centrality.
+ *
+ */
+class SpanningEdgeCentrality : public Centrality {
+protected:
+    double tol;
+    Lamg<CSRMatrix> lamg;
+    uint64_t setupTime;
+
+public:
+    /**
+     * Constructs the SpanningEdgeCentrality class for the given Graph @a G.
+     * @param G The graph.
+     * @param tol constant used for the approximation: with probability at least 1-1/n, the
+     * approximated scores are within a factor 1+tol from the exact scores
+     */
+    SpanningEdgeCentrality(const Graph &G, double tol = 0.1);
+
+    /**
+     * Destructor.
+     */
+    ~SpanningEdgeCentrality() override = default;
+
+    /**
+     * Compute spanning edge centrality scores exactly for all edges. This solves a linear system
+     * for each edge, so the empirical running time is O(m^2), where m is the number of edges in the
+     * graph.
+     */
+    void run() override;
+
+    /**
+     * Compute approximation by JL projection. This solves k linear systems, where k is
+     * log(n)/(tol^2). The empirical running time is O(km), where n is the number of nodes and m is
+     * the number of edges.
+     */
+    void runApproximation();
+
+    /**
+     * Compute approximation by JL projection in parallel. This solves k linear systems in parallel,
+     * where k is log(n)/(tol^2).
+     */
+    void runParallelApproximation();
+
+    /**
+     * This method is deprecated and will not be supported in future releases.
+     * Use runApproximation() instead.
+     * @param directory
+     * @return Elapsed time in milliseconds.
+     */
+    uint64_t TLX_DEPRECATED(runApproximationAndWriteVectors(std::string_view graphPath));
+
+    /**
+     * @return The elapsed time to setup the solver in milliseconds.
+     */
+    uint64_t getSetupTime() const;
+    /**
+     * Compute value for one edge only. This requires a single linear system, so the empricial
+     * running time is O(m).
+     * @param[in] u Endpoint of edge.
+     * @param[in] v Endpoint of edge.
+     */
+    double runForEdge(node u, node v);
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_SPANNING_EDGE_CENTRALITY_HPP_

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

@@ -0,0 +1,136 @@
+/*
+ * TopCloseness.hpp
+ *
+ *  Created on: 03.10.2014
+ *      Author: ebergamini, michele borassi
+ */
+
+#ifndef NETWORKIT_CENTRALITY_TOP_CLOSENESS_HPP_
+#define NETWORKIT_CENTRALITY_TOP_CLOSENESS_HPP_
+
+#include <memory>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/components/StronglyConnectedComponents.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class TopCloseness final : public Algorithm {
+public:
+    /**
+     * Finds the top k nodes with highest closeness centrality faster than
+     * computing it for all nodes, based on "Computing Top-k Closeness Centrality
+     * Faster in Unweighted Graphs", Bergamini et al., ALENEX16. The algorithms is
+     * based on two independent heuristics, described in the referenced paper. We
+     * recommend to use first_heu = true and second_heu = false for complex
+     * networks and first_heu = true and second_heu = true for street networks or
+     * networks with large diameters. Notice that the worst case running time of
+     * the algorithm is O(nm), where n is the number of nodes and m is the number
+     * of edges. However, for most networks the empirical running time is O(m).
+     *
+     * @param G An unweighted graph.
+     * @param k Number of nodes with highest closeness that have to be found. For
+     * example, if k = 10, the top 10 nodes with highest closeness will be
+     * computed.
+     * @param first_heu If true, the neighborhood-based lower bound is computed
+     * and nodes are sorted according to it. If false, nodes are simply sorted by
+     * degree.
+     * @param sec_heu If true, the BFSbound is re-computed at each iteration. If
+     * false, BFScut is used.
+     */
+    TopCloseness(const Graph &G, count k = 1, bool first_heu = true, bool sec_heu = true);
+
+    /**
+     * Computes top-k closeness on the graph passed in the constructor.
+     */
+    void run() override;
+
+    /**
+     * Returns a list with the k nodes with highest closeness.
+     * 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.
+     */
+    std::vector<node> topkNodesList(bool includeTrail = false);
+
+    /**
+     * Returns a list with the scores of the k nodes with highest closeness
+     * 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.
+     */
+    std::vector<edgeweight> topkScoresList(bool includeTrail = false);
+
+    /**
+     * @brief Restricts the top-k closeness computation to a subset of nodes.
+     * If the given list is empty, all nodes in the graph will be considered.
+     * Note: Actual existence of included nodes in the graph is not checked.
+     *
+     * @param nodeList Subset of nodes.
+     */
+    void restrictTopKComputationToNodes(const std::vector<node> &nodeList) {
+        nodeListPtr = &nodeList;
+    };
+
+private:
+    const Graph &G;
+    count n;
+    count k;
+    bool first_heu, sec_heu;
+    std::vector<node> topk;
+    const std::vector<node> *nodeListPtr;
+    count visEdges;
+    count n_op;
+    count trail;
+    double maxFarness = -1.0;
+    count nMaxFarness;
+    std::vector<std::vector<count>> nodesPerLevs, sumLevels;
+    std::vector<edgeweight> topkScores;
+    std::vector<double> farness;
+    std::shared_ptr<std::vector<count>> reachLPtr, reachUPtr;
+
+    std::unique_ptr<StronglyConnectedComponents> sccsPtr;
+
+    void init();
+    double BFScut(node v, double x, std::vector<bool> &visited, std::vector<count> &distances,
+                  std::vector<node> &pred, count &visEdges);
+    void computelBound1(std::vector<double> &S);
+    void BFSbound(node x, std::vector<double> &S, count &visEdges,
+                  const std::vector<bool> &toAnalyze);
+    void computeReachable();
+};
+
+inline std::vector<node> TopCloseness::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> TopCloseness::topkScoresList(bool includeTrail) {
+    assureFinished();
+    if (!includeTrail) {
+        auto begin = topkScores.begin();
+        std::vector<double> topkScoresNoTrail(begin, begin + k);
+        return topkScoresNoTrail;
+    }
+
+    return topkScores;
+}
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_CENTRALITY_TOP_CLOSENESS_HPP_