@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/auxiliary/BloomFilter.hpp

@@ -0,0 +1,70 @@
+/*
+ * BloomFilter.hpp
+ *
+ *  Created on: 08.08.2015
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_AUXILIARY_BLOOM_FILTER_HPP_
+#define NETWORKIT_AUXILIARY_BLOOM_FILTER_HPP_
+
+#include <vector>
+
+#include <networkit/Globals.hpp>
+#include <networkit/auxiliary/Log.hpp>
+
+namespace Aux {
+
+using index = NetworKit::index;
+using count = NetworKit::count;
+
+/**
+ * Bloom filter for fast set membership queries for type index with one-sided error (false
+ * positives). Uses one hash function instead of many but different random salts instead.
+ */
+class BloomFilter {
+private:
+    count numHashes;
+    count size;
+    std::vector<std::vector<char>> membership;
+    std::vector<index> salts;
+
+    /**
+     * Hashes @a key with the salt at index @a hfunc (to mimic a different hash function).
+     * @param[in] key Key to be hashed.
+     * @param[in] hfunc In principle index of a hash function, here index of a salt.
+     * @return Hash value of salted key.
+     */
+    index hash(index key, index hfunc) const;
+
+public:
+    /**
+     * Constructor. Space complexity: @a numHashes * @a size bytes.
+     * @param[in] numHashes Number of different hash functions that should be used.
+     * Actually, the implementation uses @a numHashes different random salts instead and one
+     * hash function only.
+     * @param[in] size Size of each hash array.
+     */
+    BloomFilter(count numHashes, count size = 6291469);
+
+    /**
+     * Destructor.
+     */
+    virtual ~BloomFilter() = default;
+
+    /**
+     * Inserts @a key into Bloom filter.
+     * @param[in] key Key to be inserted.
+     */
+    void insert(index key);
+
+    /**
+     * @param[in] key Key to be queried for set membership.
+     * @return True if @a is member, false otherwise.
+     */
+    bool isMember(index key) const;
+};
+
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_BLOOM_FILTER_HPP_

package/vendor/include/networkit/auxiliary/BucketPQ.hpp

@@ -0,0 +1,142 @@
+/*
+ * BucketPQ.hpp
+ *
+ *  Created on: 02.03.2017
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_AUXILIARY_BUCKET_PQ_HPP_
+#define NETWORKIT_AUXILIARY_BUCKET_PQ_HPP_
+
+#include <limits>
+#include <list>
+
+#include <networkit/Globals.hpp>
+#include <networkit/auxiliary/PrioQueue.hpp>
+
+namespace Aux {
+
+using index = NetworKit::index;
+using count = NetworKit::count;
+using Bucket = std::list<index>;
+constexpr int64_t none = std::numeric_limits<int64_t>::max();
+
+/**
+ * Addressable priority queue for values in the range [0,n) and
+ * integer keys (= priorities) in the range [minPrio, maxPrio].
+ * minPrio and maxPrio can be positive or negative, respectively with
+ * the obvious constraint minPrio <= maxPrio.
+ * Amortized constant running time for each operation.
+ */
+class BucketPQ : public PrioQueue<int64_t, index> {
+private:
+    std::vector<Bucket> buckets; // the actual buckets
+    static Bucket dummyBucket;
+    static const Bucket::iterator invalidPtr;
+
+    struct OptionalIterator {
+        bool valid;
+        Bucket::iterator iter;
+
+        void reset() {
+            valid = false;
+            iter = invalidPtr;
+        }
+        OptionalIterator() { reset(); }
+        OptionalIterator(bool valid, Bucket::iterator iter) : valid(valid), iter(iter) {}
+    };
+
+    std::vector<OptionalIterator> nodePtr; // keeps track of node positions
+    std::vector<index> myBucket;           // keeps track of current bucket for each value
+    int64_t currentMinKey;                 // current min key
+    int64_t currentMaxKey;                 // current max key
+    int64_t minAdmissibleKey;              // minimum admissible key
+    int64_t maxAdmissibleKey;              // maximum admissible key
+    count numElems;                        // number of elements stored
+    int64_t offset;                        // offset from minAdmissibleKeys to 0
+
+    /**
+     * Constructor. Not to be used, only here for overriding.
+     */
+    BucketPQ(const std::vector<int64_t> &) {}
+
+    /**
+     * Constructor. Not to be used, only here for overriding.
+     */
+    BucketPQ(uint64_t) {}
+
+    /**
+     * Called from various constructors for initializing members.
+     */
+    void construct(uint64_t capacity);
+
+public:
+    /**
+     * Builds priority queue from the vector @a keys, values are indices
+     * of @a keys.
+     * @param[in] keys Vector of keys
+     * @param[in] minAdmissibleKey Minimum admissible key
+     * @param[in] maxAdmissibleKey Maximum admissible key
+     */
+    BucketPQ(const std::vector<int64_t> &keys, int64_t minAdmissibleKey, int64_t maxAdmissibleKey);
+
+    /**
+     * Builds priority queue of the specified capacity @a capacity.
+     */
+    BucketPQ(uint64_t capacity, int64_t minAdmissibleKey, int64_t maxAdmissibleKey);
+
+    /**
+     * Default destructor
+     */
+    ~BucketPQ() override = default;
+
+    /**
+     * Inserts key-value pair (@key, @value).
+     */
+    void insert(int64_t key, index value) override;
+
+    /**
+     * Returns the element on top of the PrioQ.
+     */
+    std::pair<int64_t, index> getMin();
+
+    /**
+     * Removes the element with minimum key and returns the key-value pair.
+     */
+    std::pair<int64_t, index> extractMin() override;
+
+    /**
+     * Modifies entry with value @a value.
+     * The entry is then set to @a newKey with the same value.
+     * If the corresponding key is not present, the element will be inserted.
+     */
+    void changeKey(int64_t newKey, index value) override;
+
+    /**
+     * @return Number of elements in PQ.
+     */
+    uint64_t size() const override;
+
+    /**
+     * @return Whether or not the PQ is empty.
+     */
+    bool empty() const noexcept override;
+
+    /**
+     * @return Whether or not the PQ contains the given element.
+     */
+    bool contains(const index &value) const override;
+
+    /**
+     * Removes key-value pair given by value @a val.
+     */
+    void remove(const index &val) override;
+
+    /**
+     * @return key to given value @val.
+     */
+    virtual int64_t getKey(const index &val);
+};
+
+} /* namespace Aux */
+#endif // NETWORKIT_AUXILIARY_BUCKET_PQ_HPP_

package/vendor/include/networkit/auxiliary/Enforce.hpp

@@ -0,0 +1,117 @@
+#ifndef NETWORKIT_AUXILIARY_ENFORCE_HPP_
+#define NETWORKIT_AUXILIARY_ENFORCE_HPP_
+
+#include <cassert>
+#include <stdexcept>
+#include <string>
+
+namespace Aux {
+
+/**
+ * Enforces that @a b is true and throws an Exception otherwise.
+ *
+ * If provided, msg must not be null, otherwise the behavior of this
+ * function is undefined.
+ *
+ * @param b Boolean value whose truthiness should be enforced
+ * @param msg Message of the exception
+ */
+template <typename Exception = std::runtime_error>
+inline void enforce(bool b, const char *msg = "") {
+    assert(msg && "Message to enforce must not be nullptr");
+    if (!b) {
+        throw Exception{msg};
+    }
+}
+
+/**
+ * Enforces that @a b is true and throws an Exception otherwise.
+ *
+ * If provided, msg must not be null, otherwise the behavior of this
+ * function is undefined.
+ *
+ * @param b Boolean value whose truthiness should be enforced
+ * @param msg Message of the exception
+ */
+template <typename Exception = std::runtime_error>
+inline void enforce(bool b, std::string_view msg) {
+    enforce<Exception>(b, msg.data());
+}
+
+/**
+ * Checks that the provided fstream is opened and throws an exception otherwise.
+ *
+ * @param stream File stream whose openness should be enforced
+ */
+template <typename Stream>
+inline void enforceOpened(const Stream &stream) {
+    enforce(stream.is_open());
+}
+
+/**
+ * This namespace provides some Types with a static member-function `void enforce(bool)`
+ * that may check wether the argument is true and create some kind of failure otherwise.
+ */
+namespace Checkers {
+
+/**
+ * Checks the truthiness of the given boolean values through asserts.
+ */
+struct Asserter {
+    /**
+     * Enforces truthiness of the given boolean value @b through asserts.
+     *
+     * @param b Boolean value whose truthiness should be enforced
+     */
+    static void enforce(bool b) {
+        assert(b);
+        (void)b; // prevent warnings in release-builds
+    }
+};
+
+/**
+ * Enforces truthiness of a given boolean value by throwing an exception in case of violation.
+ */
+struct Enforcer {
+    /**
+     * Enforces that @a b is true and throws an Exception otherwise.
+     *
+     * @param b Boolean value whose truthiness should be enforced
+     */
+    static void enforce(bool b) { ::Aux::enforce(b); }
+};
+
+/**
+ * Calls std::terminate if the bool is false.
+ */
+struct Terminator {
+    /**
+     * Enforces truthiness of the given boolean value @b by terminating in case of violation.
+     *
+     * @param b Boolean value whose truthiness should be enforced
+     */
+    static void enforce(bool b) {
+        if (!b) {
+            std::terminate();
+        }
+    }
+};
+
+/**
+ * Won't look at the bool (not even in debug-mode, which is how this differs from Asserter).
+ */
+struct Ignorer {
+    /**
+     * Ignores the given boolean value and does not enforce anything.
+     *
+     * Useful for debugging purposes.
+     *
+     * @param Boolean whose value is ignored
+     */
+    static void enforce(bool) {}
+};
+} // namespace Checkers
+
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_ENFORCE_HPP_

package/vendor/include/networkit/auxiliary/FunctionTraits.hpp

@@ -0,0 +1,74 @@
+#ifndef NETWORKIT_AUXILIARY_FUNCTION_TRAITS_HPP_
+#define NETWORKIT_AUXILIARY_FUNCTION_TRAITS_HPP_
+
+#include <tuple>
+#include <type_traits>
+
+namespace Aux {
+
+// Code taken from https://functionalcpp.wordpress.com/2013/08/05/function-traits/ and slightly
+// modified
+
+template <class F>
+struct FunctionTraits;
+
+// function pointer
+template <class R, class... Args>
+struct FunctionTraits<R (*)(Args...)> : public FunctionTraits<R(Args...)> {};
+
+template <class R, class... Args>
+struct FunctionTraits<R(Args...)> {
+    using result_type = R;
+
+    static constexpr size_t arity = sizeof...(Args);
+
+    template <size_t N, bool>
+    struct arg_impl;
+    template <size_t N>
+    struct arg_impl<N, false> {};
+    template <size_t N>
+    struct arg_impl<N, true> {
+        using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
+    };
+
+    template <size_t N>
+    using arg = arg_impl < N,
+          N<arity>;
+};
+
+// member function pointer
+template <class C, class R, class... Args>
+struct FunctionTraits<R (C::*)(Args...)> : public FunctionTraits<R(C &, Args...)> {};
+
+// const member function pointer
+template <class C, class R, class... Args>
+struct FunctionTraits<R (C::*)(Args...) const> : public FunctionTraits<R(C &, Args...)> {};
+
+// member object pointer
+template <class C, class R>
+struct FunctionTraits<R(C::*)> : public FunctionTraits<R(C &)> {};
+
+// functor
+template <class F>
+struct FunctionTraits {
+private:
+    using call_type = FunctionTraits<decltype(&F::operator())>;
+
+public:
+    using result_type = typename call_type::result_type;
+
+    static constexpr size_t arity = call_type::arity - 1;
+
+    template <size_t N>
+    using arg = typename call_type::template arg<N + 1>;
+};
+
+template <class F>
+struct FunctionTraits<F &> : public FunctionTraits<F> {};
+
+template <class F>
+struct FunctionTraits<F &&> : public FunctionTraits<F> {};
+
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_FUNCTION_TRAITS_HPP_

package/vendor/include/networkit/auxiliary/HashUtils.hpp

@@ -0,0 +1,28 @@
+#ifndef NETWORKIT_AUXILIARY_HASH_UTILS_HPP_
+#define NETWORKIT_AUXILIARY_HASH_UTILS_HPP_
+
+#include <utility>
+
+namespace Aux {
+
+template <typename T>
+void hashCombine(std::size_t &seed, T const &v) {
+    // The Boost Software License, Version 1.0 applies to this function.
+    // See https://www.boost.org/LICENSE_1_0.txt
+    // https://www.boost.org/doc/libs/1_75_0/doc/html/hash/reference.html#boost.hash_combine
+    seed ^= std::hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+}
+
+struct PairHash {
+    template <typename A, typename B>
+    std::size_t operator()(const std::pair<A, B> &pair) const {
+        std::size_t seed = 0;
+        hashCombine(seed, pair.first);
+        hashCombine(seed, pair.second);
+        return seed;
+    }
+};
+
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_HASH_UTILS_HPP_

package/vendor/include/networkit/auxiliary/IncrementalUniformRandomSelector.hpp

@@ -0,0 +1,52 @@
+#ifndef NETWORKIT_AUXILIARY_INCREMENTAL_UNIFORM_RANDOM_SELECTOR_HPP_
+#define NETWORKIT_AUXILIARY_INCREMENTAL_UNIFORM_RANDOM_SELECTOR_HPP_
+
+#include <cstddef>
+
+#include <networkit/auxiliary/Random.hpp>
+
+namespace Aux {
+
+/**
+ * Select uniformly at random from a set of elements
+ * that is discovered incrementally. Every time you
+ * discover a new element, you tell the selector and
+ * it will tell if you should keep the new element or
+ * your old element. As more and more elements are
+ * discovered, it will be less and less likely that
+ * the new element is chosen in order to ensure that
+ * the selection is uniformly at random. The process
+ * can be reset when a new class of elements is found
+ * that shall be used instead.
+ */
+class IncrementalUniformRandomSelector {
+public:
+    /**
+     * Initialize the random select for one element.
+     */
+    IncrementalUniformRandomSelector() : counter(1){};
+
+    /**
+     * Add the next element.
+     *
+     * Note that this must not be called for the first element.
+     *
+     * @return If the new element shall be accepted/kept.
+     */
+    bool addElement() {
+        ++counter;
+        return (Random::real() < 1.0 / static_cast<double>(counter));
+    }
+
+    /**
+     * Reset the process to one element again.
+     */
+    void reset() { counter = 1; }
+
+private:
+    size_t counter;
+};
+
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_INCREMENTAL_UNIFORM_RANDOM_SELECTOR_HPP_

package/vendor/include/networkit/auxiliary/Log.hpp

@@ -0,0 +1,119 @@
+#ifndef NETWORKIT_AUXILIARY_LOG_HPP_
+#define NETWORKIT_AUXILIARY_LOG_HPP_
+
+#include <sstream>
+#include <string>
+#include <string_view>
+
+#include <networkit/auxiliary/StringBuilder.hpp>
+
+#ifdef _MSC_VER
+#define NETWORKT_PRETTY_FUNCTION __FUNCSIG__
+#else
+#define NETWORKT_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#endif // _MSC_VER
+
+/// Logging without format string
+#define LOG_AT(level, ...) \
+    ::Aux::Log::log({__FILE__, NETWORKT_PRETTY_FUNCTION, __LINE__}, level, __VA_ARGS__)
+#define FATAL(...) LOG_AT(::Aux::Log::LogLevel::FATAL, __VA_ARGS__)
+#define ERROR(...) LOG_AT(::Aux::Log::LogLevel::ERROR, __VA_ARGS__)
+#define WARN(...) LOG_AT(::Aux::Log::LogLevel::WARN, __VA_ARGS__)
+#define INFO(...) LOG_AT(::Aux::Log::LogLevel::INFO, __VA_ARGS__)
+
+/// Logging with format string
+#define LOG_ATF(level, ...) \
+    ::Aux::Log::logF({__FILE__, NETWORKT_PRETTY_FUNCTION, __LINE__}, level, __VA_ARGS__)
+#define FATALF(...) LOG_ATF(::Aux::Log::LogLevel::FATAL, __VA_ARGS__)
+#define ERRORF(...) LOG_ATF(::Aux::Log::LogLevel::ERROR, __VA_ARGS__)
+#define WARNF(...) LOG_ATF(::Aux::Log::LogLevel::WARN, __VA_ARGS__)
+#define INFOF(...) LOG_ATF(::Aux::Log::LogLevel::INFO, __VA_ARGS__)
+
+// DEBUG and TRACE are no-ops if NETWORKIT_RELEASE_LOGGING is defined.
+#if defined(NETWORKIT_RELEASE_LOGGING)
+#define NETWORKIT_LOG_DUMMY(...) \
+    do { \
+    } while (false)
+#define DEBUG(...) NETWORKIT_LOG_DUMMY(__VA_ARGS__)
+#define DEBUGF(...) NETWORKIT_LOG_DUMMY(__VA_ARGS__)
+#define TRACE(...) NETWORKIT_LOG_DUMMY(__VA_ARGS__)
+#define TRACEF(...) NETWORKIT_LOG_DUMMY(__VA_ARGS__)
+#define TRACEPOINT NETWORKIT_LOG_DUMMY()
+#else
+#define DEBUG(...) LOG_AT(::Aux::Log::LogLevel::DEBUG, __VA_ARGS__)
+#define TRACE(...) LOG_AT(::Aux::Log::LogLevel::TRACE, __VA_ARGS__)
+
+#define DEBUGF(...) LOG_ATF(::Aux::Log::LogLevel::DEBUG, __VA_ARGS__)
+#define TRACEF(...) LOG_ATF(::Aux::Log::LogLevel::TRACE, __VA_ARGS__)
+
+#define TRACEPOINT LOG_AT(::Aux::Log::LogLevel::TRACE, "tracepoint")
+#endif // defined(NETWORKIT_RELEASE_LOGGING)
+
+namespace Aux {
+namespace Log {
+
+struct Location {
+    const char *file;
+    const char *function;
+    const int line;
+};
+
+enum class LogLevel {
+    TRACE,
+    DEBUG,
+    INFO,
+    WARN,
+    ERROR,
+    FATAL,
+    QUIET,         // Emits no log messages at all.
+    trace = TRACE, // this + following added for backwards compatibility
+    debug = DEBUG,
+    info = INFO,
+    warn = WARN,
+    error = ERROR,
+    fatal = FATAL,
+    quiet = QUIET
+};
+
+/**
+ * Accept loglevel as string and set.
+ * @param logLevel as string
+ */
+void setLogLevel(std::string_view logLevel);
+
+/**
+ * @return current loglevel as string
+ */
+std::string getLogLevel();
+
+namespace Impl {
+void log(const Location &loc, LogLevel p, std::string_view msg);
+} // namespace Impl
+
+///! Returns true iff logging at the provided level is currently activated
+bool isLogLevelEnabled(LogLevel p) noexcept;
+
+template <typename... T>
+void log(const Location &loc, LogLevel p, const T &...args) {
+    if (!isLogLevelEnabled(p))
+        return;
+
+    std::stringstream stream;
+    printToStream(stream, args...);
+    Impl::log(loc, p, stream.str());
+}
+
+template <typename... T>
+void logF(const Location &loc, LogLevel p, std::string_view format, const T &...args) {
+    if (!isLogLevelEnabled(p))
+        return;
+
+    std::stringstream stream;
+    printToStreamF(stream, format, args...);
+    Impl::log(loc, p, stream.str());
+}
+
+} // namespace Log
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_LOG_HPP_

package/vendor/include/networkit/auxiliary/MissingMath.hpp

@@ -0,0 +1,48 @@
+/*
+ * MissingMath.hpp
+ *
+ *  Created on: 21.03.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_AUXILIARY_MISSING_MATH_HPP_
+#define NETWORKIT_AUXILIARY_MISSING_MATH_HPP_
+
+#include <cassert>
+#include <cinttypes>
+#include <cmath>
+#include <stdexcept>
+
+namespace Aux {
+
+/**
+ * Math functions not provided by the standard library.
+ */
+namespace MissingMath {
+
+inline int64_t binomial(int64_t n, int64_t k) {
+    if (k == 0)
+        return 1;
+    if (2 * k > n)
+        return binomial(n, n - k);
+
+    int64_t b = n - k + 1;
+    for (int64_t i = 2; i <= k; ++i) {
+        b = b * (n - k + i);
+        b = b / i;
+    }
+    return b;
+}
+
+inline double log_b(double x, double b) {
+    if (x == 0) {
+        throw std::domain_error("log(0) is undefined");
+    }
+    assert(std::log(b) != 0);
+    return std::log(x) / std::log(b);
+}
+
+} /* namespace MissingMath */
+
+} /* namespace Aux */
+#endif // NETWORKIT_AUXILIARY_MISSING_MATH_HPP_

package/vendor/include/networkit/auxiliary/Multiprecision.hpp

@@ -0,0 +1,17 @@
+/*
+ * Multiprecision.hpp
+ *
+ *  Created on: 21.03.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_AUXILIARY_MULTIPRECISION_HPP_
+#define NETWORKIT_AUXILIARY_MULTIPRECISION_HPP_
+
+#include <ttmath/ttmath.h>
+
+namespace NetworKit {
+using bigfloat = ttmath::Big<TTMATH_BITS(64), TTMATH_BITS(64)>; ///< big floating point number
+}
+
+#endif // NETWORKIT_AUXILIARY_MULTIPRECISION_HPP_