@ladybugmem/icebug 0.1.0 → 0.1.2

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

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

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

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

@@ -1,43 +0,0 @@
-#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

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

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

@@ -1,48 +0,0 @@
-#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

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

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

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