@ladybugmem/icebug 0.1.0 → 0.1.2

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

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

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

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

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

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

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