@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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

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

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

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

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

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