@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/randomization/GlobalTradeSequence.hpp

@@ -0,0 +1,303 @@
+/*
+ * GlobalTradeSequence.hpp
+ *
+ * This header file is deprecated and will eventually be removed.
+ * Do not included it directly.
+ *
+ *  Created on: 23.05.2018
+ *      Author: Manuel Penschuck <networkit@manuel.jetzt>
+ */
+
+#ifndef NETWORKIT_RANDOMIZATION_GLOBAL_TRADE_SEQUENCE_HPP_
+#define NETWORKIT_RANDOMIZATION_GLOBAL_TRADE_SEQUENCE_HPP_
+
+#ifndef NETWORKIT_PRIVATE_RANDOMIZATION_GLOBAL_TRADE_SEQUENCE_HPP_
+#if defined(__clang__) || defined(__GNUG__)
+#warning "This header file is deprecated. Do not included it directly."
+#elif defined(_MSC_VER)
+#pragma message("This header file is deprecated. Do not included it directly.")
+#endif
+#endif // NETWORKIT_PRIVATE_RANDOMIZATION_GLOBAL_TRADE_SEQUENCE_HPP_
+
+#include <cassert>
+#include <cmath>
+#include <iostream>
+#include <random>
+#include <tuple>
+#include <type_traits>
+
+#include <networkit/Globals.hpp>
+#include <networkit/auxiliary/Log.hpp>
+
+namespace NetworKit {
+namespace CurveballDetails {
+
+template <typename T>
+class FixedLinearCongruentialMap; // forward declaration (implementation below)
+
+/**
+ * Computes a bijection f:[p]->[p], x -> (a*x+b) mod p where p is chosen
+ * as the smallest p >= n and p prime. a and b are drawn unif at random.
+ * @tparam T
+ */
+template <typename T>
+class LinearCongruentialMap {
+    static_assert(!std::is_signed<T>::value, "LinearCongruentialMap requires unsigned types");
+
+    using signed_value_type = typename std::make_signed<T>::type;
+    using signed_tuple = std::tuple<signed_value_type, signed_value_type, signed_value_type>;
+
+    friend FixedLinearCongruentialMap<T>;
+
+public:
+    using value_type = T;
+
+    LinearCongruentialMap() {}
+
+    explicit LinearCongruentialMap(value_type n, unsigned seed = 0) : n(n), p(computeNextPrime(n)) {
+        std::mt19937_64 prng(seed * n + n);
+        sampleParameters(prng);
+    }
+
+    LinearCongruentialMap(value_type n, std::mt19937_64 &prng) : n(n), p(computeNextPrime(n)) {
+        sampleParameters(prng);
+    }
+
+    LinearCongruentialMap(value_type n, value_type a, value_type b)
+        : n(n), p(computeNextPrime(n)), a(a),
+          ainv(static_cast<value_type>((std::get<1>(gcdExtended(a, p)) + p) % p)), b(b) {}
+
+    LinearCongruentialMap(const LinearCongruentialMap &) = default;
+    LinearCongruentialMap(LinearCongruentialMap &&) noexcept = default;
+    LinearCongruentialMap &operator=(const LinearCongruentialMap &) = default;
+    LinearCongruentialMap &operator=(LinearCongruentialMap &&) noexcept = default;
+
+    //! Hashes [n] to [p] with (a*x+b) mod p
+    value_type hash(value_type n) const { return (a * n + b) % p; }
+
+    //! Alias to hash(n)
+    value_type operator()(value_type n) const { return hash(n); }
+
+    //! invert(hash(x)) == x
+    value_type invert(value_type y) const { return ainv * (y + p - b) % p; }
+
+    //! Is true if there exists no x in [n], s.t. h(x) == y,
+    //! i.e. it can be used to determine if the map maps to y
+    bool isGap(value_type y) const { return invert(y) >= n; }
+
+    //! randomly samples parameters a and b
+    void sampleParameters(std::mt19937_64 &prng) {
+        const value_type max_a = std::numeric_limits<value_type>::max() / n - 1;
+        if (max_a < p) {
+            std::cerr << "WARNING: Reduce randomness of hash function to avoid integer "
+                         "precision issues\n";
+        }
+
+        a = std::uniform_int_distribution<value_type>{1, std::min<value_type>(p, max_a) - 1}(prng);
+        ainv = static_cast<value_type>((std::get<1>(gcdExtended(a, p)) + p) % p);
+        b = std::uniform_int_distribution<value_type>{0, p - 1}(prng);
+    }
+
+    //! Sets parameters a = 1 and b = 0
+    void setAsIdentity() {
+        a = 1;
+        b = 0;
+        ainv = 1;
+    }
+
+    value_type param_a() const { return a; }
+    value_type param_ainv() const { return ainv; }
+    value_type param_b() const { return b; }
+    value_type param_p() const { return p; }
+
+private:
+    value_type n; //< number of elements to be mapped
+    value_type p; //< size of the universe chosen to be >= n
+
+    value_type a;    //< multiplicative parameter in hash
+    value_type ainv; //< multiplicative invert
+
+    value_type b; //< additive parameter in hash
+
+    value_type computeNextPrime(value_type n) const {
+        auto is_prime = [](value_type n) {
+            if (n <= 3)
+                return true;
+            if (0 == n % 2 || 0 == n % 3)
+                return false;
+
+            const value_type sqrt = static_cast<value_type>(std::sqrt(n) + 2);
+            for (value_type i = 5; i < sqrt; i += 6)
+                if (0 == n % i)
+                    return false;
+
+            return true;
+        };
+
+        while (!is_prime(n))
+            n++;
+
+        return n;
+    }
+
+    // extended Euclidean algorithm with 1 = gcd(a, p) = a*s + t*p mod p = a*s
+    // --> s = 1/a
+    static signed_tuple gcdExtended(signed_value_type a, signed_value_type b) noexcept {
+        if (a == 0)
+            return signed_tuple{b, 0, 1};
+
+        const value_type div = b / a;
+        const value_type rem = b % a;
+
+        const auto recursion = gcdExtended(rem, a);
+        value_type x = std::get<2>(recursion) - div * std::get<1>(recursion);
+
+        return signed_tuple(std::get<0>(recursion), x, std::get<1>(recursion));
+    }
+};
+
+/**
+ * Computes a bijection f:[p]->[p], x -> (a*x+b) mod p where p is chosen
+ * as the smallest p >= n and p prime. a and b are drawn unif at random.
+ * @tparam T
+ */
+template <typename T>
+class FixedLinearCongruentialMap {
+    static_assert(!std::is_signed<T>::value, "LinearCongruentialMap requires unsigned types");
+
+    using signed_value_type = typename std::make_signed<T>::type;
+    using signed_tuple = std::tuple<signed_value_type, signed_value_type, signed_value_type>;
+
+public:
+    using value_type = T;
+
+    FixedLinearCongruentialMap() {}
+
+    explicit FixedLinearCongruentialMap(value_type n, unsigned seed = 0) : n(n) {
+        std::mt19937_64 prng(seed * n + n);
+        sampleParameters(prng);
+    }
+
+    FixedLinearCongruentialMap(value_type n, std::mt19937_64 &prng) : n(n) {
+        sampleParameters(prng);
+    }
+
+    FixedLinearCongruentialMap(value_type n, value_type a, value_type b)
+        : n(n), a(a), //
+          ainv(static_cast<value_type>(
+              (std::get<1>(LinearCongruentialMap<T>::gcdExtended(a, p)) + p) % p)),
+          b(b) {}
+
+    FixedLinearCongruentialMap(const FixedLinearCongruentialMap &) = default;
+    FixedLinearCongruentialMap(FixedLinearCongruentialMap &&) noexcept = default;
+    FixedLinearCongruentialMap &operator=(const FixedLinearCongruentialMap &) = default;
+    FixedLinearCongruentialMap &operator=(FixedLinearCongruentialMap &&) noexcept = default;
+
+    //! Hashes [n] to [p] with (a*x+b) mod p
+    value_type hash(value_type n) const { return (a * n + b) % p; }
+
+    //! Alias to hash(n)
+    value_type operator()(value_type n) const { return hash(n); }
+
+    //! invert(hash(x)) == x
+    value_type invert(value_type y) const { return ainv * (y + p - b) % p; }
+
+    //! Is true if there exists no x in [n], s.t. h(x) == y,
+    //! i.e. it can be used to determine if the map maps to y
+    bool isGap(value_type y) const { return invert(y) >= n; }
+
+    //! randomly samples parameters a and b
+    void sampleParameters(std::mt19937_64 &prng) {
+        if (n >= p)
+            throw std::runtime_error("Support only up to 2147483646 nodes");
+
+        a = std::uniform_int_distribution<value_type>{1, p - 1}(prng);
+        ainv = static_cast<value_type>(
+            (std::get<1>(LinearCongruentialMap<T>::gcdExtended(a, p)) + p) % p);
+        b = std::uniform_int_distribution<value_type>{0, p - 1}(prng);
+    }
+
+    //! Sets parameters a = 1 and b = 0
+    void setAsIdentity() {
+        a = 1;
+        b = 0;
+        ainv = 1;
+    }
+
+    value_type param_a() const { return a; }
+    value_type param_ainv() const { return ainv; }
+    value_type param_b() const { return b; }
+    value_type param_p() const { return p; }
+
+private:
+    value_type n; //< number of elements to be mapped
+    static constexpr value_type p = 2147483647;
+
+    value_type a;    //< multiplicative parameter in hash
+    value_type ainv; //< multiplicative invert
+
+    value_type b; //< additive parameter in hash
+};
+
+/**
+ * Handles a sequence of num_global_trades hash functions each with its own
+ * set of parameters. It prominently exposes the "current" hash function
+ * and its successors. Switching the current hash function is possible with
+ * using the switch_to_round method.
+ *
+ * hash, invert  access the "current" hash function
+ * hash_next     accesses the successor of "current" which is the identity if
+ *               there are no further hash functions
+ *
+ * @tparam Default constructable, copy-able, requires methods
+ *         sample_parameters, set_as_identity, hash and (optinally) invert
+ */
+template <typename Hash>
+class GlobalTradeSequence {
+public:
+    using value_type = typename Hash::value_type;
+
+    GlobalTradeSequence(node num_nodes, size_t num_global_trades, std::mt19937_64 &prng) {
+        hashFunctors.reserve(num_global_trades);
+        hashFunctors.push_back(Hash{num_nodes, prng});
+
+        while (hashFunctors.size() < num_global_trades) {
+            // we copy the hash function, rather than constructing a new one,
+            // to avoid repeated computations, such as the next larger prime
+            // number
+            hashFunctors.push_back(hashFunctors.back());
+            hashFunctors.back().sampleParameters(prng);
+        }
+
+        switchToRound(0);
+    }
+
+    void switchToRound(size_t round) {
+        assert(round < hashFunctors.size());
+        current = hashFunctors[round];
+        if (round + 1 == hashFunctors.size()) {
+            next = current;
+            next.setAsIdentity();
+        } else {
+            next = hashFunctors[round + 1];
+        }
+    }
+
+    value_type hash(node u) const { return current.hash(u); }
+
+    node invert(value_type u) const { return current.invert(u); }
+
+    value_type hashNext(node u) const { return next.hash(u); }
+
+    size_t numberOfRounds() const { return hashFunctors.size(); }
+
+private:
+    std::vector<Hash> hashFunctors;
+    Hash current;
+    Hash next;
+};
+
+} // namespace CurveballDetails
+} // namespace NetworKit
+
+#endif // NETWORKIT_RANDOMIZATION_GLOBAL_TRADE_SEQUENCE_HPP_

package/vendor/include/networkit/reachability/AllSimplePaths.hpp

@@ -0,0 +1,122 @@
+/*
+ *  AllSimplePaths.hpp
+ *
+ *  Created on: 23.06.2017
+ *      Author: Eugenio Angriman <angrimae@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_REACHABILITY_ALL_SIMPLE_PATHS_HPP_
+#define NETWORKIT_REACHABILITY_ALL_SIMPLE_PATHS_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Determines all the possible simple paths from a given source node to a target node of a directed
+ * unweighted graph. It also accepts a cutoff value i.e. the maximum length of paths.
+ */
+class AllSimplePaths final : public Algorithm {
+
+public:
+    /**
+     * Creates the AllSimplePaths class for @a G, source @a s and target @a t.
+     *
+     * @param G The graph.
+     * @param source The source node.
+     * @param target The target node.
+     * @param cutoff The maximum length of the paths.
+     */
+    AllSimplePaths(const Graph &G, node source, node target, count cutoff = none);
+
+    ~AllSimplePaths() override = default;
+
+    /**
+     * This method computes all possible paths from a given source node to a target node.
+     */
+    void run() override;
+
+    /**
+     * This method returns the number of simple paths from the source node to the target node.
+     */
+    count numberOfSimplePaths();
+
+    /*
+     * This method returns a vector that contains all the simple paths from a source node to a
+     * target node represented by vectors. Each path contains the source node as the first element
+     * and the target node as the last element.
+     */
+    std::vector<std::vector<node>> getAllSimplePaths();
+
+    /*
+     * This method iterates over all the simple paths and it is far more efficient than calling
+     * getAllSimplePaths().
+     */
+    template <typename L>
+    void forAllSimplePaths(L handle);
+
+    /*
+     * This method iterates in parallel over all the simple paths and it is far more efficient than
+     * calling getAllSimplePaths().
+     */
+    template <typename L>
+    void parallelForAllSimplePaths(L handle);
+
+private:
+    // This method computes all the paths after a reverse BFS from the target node and a normal BFS
+    // from the source node.
+    void computePaths();
+
+    // This method returns a queue that contains all the nodes that could be part of a path from the
+    // source to the target that crosses @s.
+    std::vector<node> getAvailableSources(node s, count pathLength = 0);
+
+    // The graph
+    const Graph *G;
+    // The source node
+    node source;
+    // The target node
+    node target;
+    // The cutoff i.e. maximum length of paths from source to target. It is optional.
+    count cutoff;
+
+    // This vector contains the distance from each node to the target node.
+    std::vector<count> distanceToTarget;
+    // This vector contains the distance from the source node to each node.
+    std::vector<count> distanceFromSource;
+    // This vector contains all the possible paths from source to target.
+    std::vector<std::vector<node>> paths;
+};
+
+inline count AllSimplePaths::numberOfSimplePaths() {
+    assureFinished();
+    return paths.size();
+}
+
+inline std::vector<std::vector<node>> AllSimplePaths::getAllSimplePaths() {
+    assureFinished();
+    return paths;
+}
+
+template <typename L>
+void AllSimplePaths::forAllSimplePaths(L handle) {
+    assureFinished();
+    for (std::vector<std::vector<node>>::iterator it = paths.begin(); it != paths.end(); ++it) {
+        handle(*it);
+    }
+}
+
+template <typename L>
+void AllSimplePaths::parallelForAllSimplePaths(L handle) {
+    assureFinished();
+#pragma omp parallel for schedule(guided)
+    for (omp_index i = 0; i < static_cast<omp_index>(paths.size()); ++i) {
+        handle(paths[i]);
+    }
+}
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_REACHABILITY_ALL_SIMPLE_PATHS_HPP_

package/vendor/include/networkit/reachability/ReachableNodes.hpp

@@ -0,0 +1,83 @@
+
+#ifndef NETWORKIT_REACHABILITY_REACHABLE_NODES_HPP_
+#define NETWORKIT_REACHABILITY_REACHABLE_NODES_HPP_
+
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup reachability
+ */
+class ReachableNodes final : public Algorithm {
+public:
+    /**
+     * Determines or estimates the number of reachable nodes from each node in the graph.
+     *
+     * @param G The graph.
+     * @param exact Whether or not to compute the number of reachable nodes exactly. Only used for
+     * directed graphs, on undirected graphs the number of reachable nodes from every node can be
+     * computed in linear time.
+     */
+    ReachableNodes(const Graph &G, bool exact = true);
+
+    /**
+     * Runs the algorithm.
+     */
+    void run() override;
+
+    /**
+     * Returns the number of reachable nodes from the given node @a u. Only available if @a exact is
+     * true.
+     *
+     * @param u A node.
+     * @returns The number of nodes reachable from @a u.
+     */
+    count numberOfReachableNodes(node u) const {
+        assureFinished();
+        if (!exact)
+            throw std::runtime_error("The number of nodes is not computed exactly, run the "
+                                     "algorithm with exact = true.");
+        return reachableLB[u];
+    }
+
+    /**
+     * Returns a lower bound of the number of reachable nodes from the given node @a u.
+     *
+     * @param u A node.
+     * @returns Lower bound of number of nodes reachable from @a u.
+     */
+    count numberOfReachableNodesLB(node u) const { return reachableLB[u]; }
+
+    /**
+     * Returns an upper bound of the number of reachable nodes from the given node @a u.
+     *
+     * @param u A node.
+     * @returns Upper bound of number of nodes reachable from @a u.
+     */
+    count numberOfReachableNodesUB(node u) const {
+        assureFinished();
+        if (G->isDirected())
+            return exact ? reachableLB[u] : reachableUB[u];
+        else
+            return reachableLB[u];
+    }
+
+    /*
+     * Whether or not to compute the reachable nodes exactly.
+     */
+    bool exact;
+
+private:
+    const Graph *G;
+    std::vector<count> reachableLB, reachableUB;
+
+    void runDirected();
+    void runUndirected();
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_REACHABILITY_REACHABLE_NODES_HPP_

package/vendor/include/networkit/scd/ApproximatePageRank.hpp

@@ -0,0 +1,51 @@
+/*
+ * ApproximatePageRank.hpp
+ *
+ *  Created on: 26.02.2014
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_SCD_APPROXIMATE_PAGE_RANK_HPP_
+#define NETWORKIT_SCD_APPROXIMATE_PAGE_RANK_HPP_
+
+#include <set>
+#include <unordered_map>
+#include <vector>
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * Computes an approximate PageRank vector from a given seed.
+ */
+class ApproximatePageRank final {
+    const Graph *g;
+    double alpha;
+    double eps;
+
+    std::unordered_map<node, std::pair<double, double>> prRes;
+
+public:
+    /**
+     * @param g Graph for which an APR is computed.
+     * @param alpha Loop probability of random walk.
+     * @param epsilon Error tolerance.
+     */
+    ApproximatePageRank(const Graph &g, double alpha, double epsilon = 1e-12);
+
+    /**
+     * @return Approximate PageRank vector from @a seeds with parameters
+     *         specified in the constructor.
+     */
+    std::vector<std::pair<node, double>> run(const std::set<node> &seeds);
+
+    /**
+     * @return Approximate PageRank vector from @a seed with parameters
+     *         specified in the constructor.
+     */
+    std::vector<std::pair<node, double>> run(node seed);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_SCD_APPROXIMATE_PAGE_RANK_HPP_

package/vendor/include/networkit/scd/CliqueDetect.hpp

@@ -0,0 +1,55 @@
+#ifndef NETWORKIT_SCD_CLIQUE_DETECT_HPP_
+#define NETWORKIT_SCD_CLIQUE_DETECT_HPP_
+
+#include <networkit/scd/SelectiveCommunityDetector.hpp>
+
+namespace NetworKit {
+
+/**
+ * The CliqueDetect algorithm. It finds the largest clique in the seed node's neighborhood.
+ *
+ * The algorithm can handle weighted graphs. There, the clique with the highest sum of internal edge
+ * weights is returned. This sum includes edge weights to the seed node(s) to ensure that cliques
+ * that are well-connected to the seed node(s) are preferred.
+ *
+ * See also: Hamann, M.; Röhrs, E.; Wagner, D. Local Community Detection Based on Small Cliques.
+ * Algorithms 2017, 10, 90. https://doi.org/10.3390/a10030090
+ */
+class CliqueDetect : public SelectiveCommunityDetector {
+
+public:
+    /**
+     * Construct a Cliquedetect object.
+     *
+     * @param[in] G The graph to detect communities on
+     */
+    CliqueDetect(const Graph &g);
+
+    /**
+     * Expands a single seed node/vertex into a maximal clique.
+     *
+     * @param[in] s the seed node
+     * @return A community of the seed node
+     */
+    std::set<node> expandOneCommunity(node seed) override;
+
+    /**
+     * Detect a single clique for the given seed nodes.
+     *
+     * The resulting community is a clique iff the seeds form a clique.
+     * Otherwise, only the added nodes form a clique that is fully connected
+     * to the seed nodes.
+     *
+     * @param seeds The seeds for the community.
+     * @return The found community as set of nodes.
+     */
+    std::set<node> expandOneCommunity(const std::set<node> &seeds) override;
+
+protected:
+    std::vector<node> getMaximumWeightClique(const std::vector<node> &nodes,
+                                             const std::vector<edgeweight> &seedToNodeWeight) const;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_SCD_CLIQUE_DETECT_HPP_

package/vendor/include/networkit/scd/CombinedSCD.hpp

@@ -0,0 +1,51 @@
+#ifndef NETWORKIT_SCD_COMBINED_SCD_HPP_
+#define NETWORKIT_SCD_COMBINED_SCD_HPP_
+
+#include <networkit/scd/SelectiveCommunityDetector.hpp>
+
+namespace NetworKit {
+/**
+ * Helper for combining two selective community detection algorithms.
+ *
+ * This allows to combine two SCD algorithms such that first the first
+ * algorithm is executed on the given seed(s) and then the result of
+ * the first algorithm is used as the seed set of the second algorithm.
+ * This is particularly useful for seeding an algorithm with a clique.
+ *
+ * @author Michael Hamann <michael.hamann@kit.edu>
+ */
+class CombinedSCD : public SelectiveCommunityDetector {
+public:
+    /**
+     * Initialize the combined algorithm with the given graph and the given two algorithms.
+     *
+     * @param G The graph to work on.
+     * @param first The first algorithm that is run with the given seed(s).
+     * @param secodn The second algorithm that is run with the result of the first algorithm.
+     */
+    CombinedSCD(const Graph &g, SelectiveCommunityDetector &first,
+                SelectiveCommunityDetector &second);
+
+    /**
+     * Expand a community with the given seed node using first and second algorithm.
+     *
+     * @param s The seed node to start with.
+     * @return The community found by the second algorithm.
+     */
+    std::set<node> expandOneCommunity(node s) override;
+
+    /**
+     * Expand a community with the given seed nodes using first and second algorithm.
+     *
+     * @param s The seed nodes to start with.
+     * @return The community found by the second algorithm.
+     */
+    std::set<node> expandOneCommunity(const std::set<node> &s) override;
+
+protected:
+    SelectiveCommunityDetector &first;
+    SelectiveCommunityDetector &second;
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_SCD_COMBINED_SCD_HPP_