@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,307 @@
+#ifndef NETWORKIT_AUXILIARY_NUMBER_PARSING_HPP_
+#define NETWORKIT_AUXILIARY_NUMBER_PARSING_HPP_
+
+#include <algorithm>
+#include <cassert>
+#include <cctype>
+#include <cstdint>
+#include <limits>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+
+#include <networkit/auxiliary/Enforce.hpp>
+
+namespace Aux {
+namespace Parsing {
+
+namespace Impl {
+
+template <typename CharIterator>
+std::tuple<CharIterator, char> dropSpaces(CharIterator it, CharIterator end);
+
+template <typename Integer>
+double powerOf10(Integer exp);
+
+class IntegerTag {};
+
+template <typename Integer, typename CharIterator, typename ValidationPolicy>
+std::tuple<Integer, CharIterator> strTo(CharIterator it, CharIterator end, IntegerTag);
+
+class RealTag {};
+
+template <typename Real, typename CharIterator, typename ValidationPolicy>
+std::tuple<Real, CharIterator> strTo(CharIterator it, CharIterator end, RealTag);
+
+template <typename T>
+using ArithmeticTag = typename std::conditional<
+    std::is_integral<T>::value, IntegerTag,
+    typename std::conditional<std::is_floating_point<T>::value, RealTag, void>::type>::type;
+
+} // namespace Impl
+
+/**
+ * Parses a range of characters as number.
+ *
+ * @param Number must be either a floating-point-type or an integer-type
+ * @param CharIterator must be a valid input-iterator over a type that is
+ *                     implicitly convertable to char
+ * @param ValidationPolicy must be a type that is compatible to the checkers from Enforce.h,
+ *                         the default is Asserter, which will check conditions via assert()
+ * @param it the start of the character-range
+ * @param end the end of the character-range
+ *
+ * Requirements: The range [it, end) must contain a valid number.
+ *
+ * @return: A tuple of the parsed value and the iterator after parsing the number and dropping
+ *           any surrounding whitespace.
+ *
+ */
+template <typename Number, typename CharIterator, typename ValidationPolicy = Checkers::Asserter>
+std::tuple<Number, CharIterator> strTo(CharIterator it, CharIterator end) {
+    return Impl::strTo<Number, CharIterator, ValidationPolicy>(it, end,
+                                                               Impl::ArithmeticTag<Number>{});
+}
+
+namespace Impl {
+
+template <typename Integer, typename CharIterator, typename ValidationPolicy>
+std::tuple<Integer, CharIterator> strTo(CharIterator it, const CharIterator end, IntegerTag) {
+    using Impl::dropSpaces;
+    ValidationPolicy::enforce(it != end);
+
+    char c = *it;
+    std::tie(it, c) = dropSpaces(it, end);
+
+    bool isNegative = false;
+    if (std::is_signed<Integer>::value) { // this should be optimized away entirely
+        switch (c) {
+        case '-':
+            isNegative = true;
+            // fallthrough
+        case '+':
+            ++it;
+            if (it == end) {
+                throw std::invalid_argument{"string contains no digits after sign"};
+            }
+            c = *it;
+            break;
+        default:
+            break;
+        }
+    }
+
+    if (!isdigit(c)) {
+        throw std::invalid_argument{"string contains no digits"};
+    }
+
+    Integer val = 0;
+    while (true) {
+        ValidationPolicy::enforce(std::numeric_limits<Integer>::max() / 10 >= val);
+
+        val *= 10;
+
+        c -= '0';
+        ValidationPolicy::enforce(std::numeric_limits<Integer>::max() - c >= val);
+
+        val += c;
+
+        ++it;
+        if (it == end) {
+            break;
+        }
+        c = *it;
+        if (!isdigit(c)) {
+            break;
+        }
+    }
+
+    if (isNegative) {
+        val = -val;
+    }
+
+    std::tie(it, c) = dropSpaces(it, end);
+
+    return std::make_tuple(val, it);
+}
+
+template <typename Real, typename CharIterator, typename ValidationPolicy>
+std::tuple<Real, CharIterator> strTo(CharIterator it, const CharIterator end, RealTag) {
+
+    static_assert(std::numeric_limits<Real>::max_digits10
+                      <= std::numeric_limits<std::uintmax_t>::digits10,
+                  "can't safe mantissa in biggest integer");
+
+    using Impl::dropSpaces;
+    using Impl::powerOf10;
+
+    char c;
+    bool isNegative = false;
+    std::uintmax_t mantissa = 0;
+    int exp = 0;
+
+    auto makeReturnValue = [&]() {
+        Real fp_mantissa = mantissa;
+        Real value = fp_mantissa * powerOf10(exp);
+        if (isNegative) {
+            value = -value;
+        }
+        return std::make_tuple(value, it);
+    };
+
+    // drop whitespace:
+    std::tie(it, c) = dropSpaces(it, end);
+
+    ValidationPolicy::enforce(it != end);
+
+    // set sign:
+    switch (c) {
+    case '-':
+        isNegative = true;
+        // fallthrough
+    case '+':
+        ++it;
+        if (it == end) {
+            throw std::invalid_argument{"string contains no digits"};
+        }
+        c = *it;
+        break;
+    default:
+        break;
+    }
+
+    // number of decimal digits that can be stored in the mantissa and the used integer
+    unsigned remainingDigits = std::numeric_limits<Real>::max_digits10;
+
+    // read 'big' part of the mantissa:
+    while (remainingDigits > 0) {
+        if (!isdigit(c)) {
+            break;
+        }
+        --remainingDigits;
+        mantissa *= 10;
+        mantissa += c - '0';
+        ++it;
+        if (it == end) {
+            return makeReturnValue();
+        }
+        c = *it;
+    }
+    if (remainingDigits == 0) {
+        if (isdigit(c)) {
+            // round correctly:
+            if (c - '0' >= 5) {
+                ++mantissa;
+            }
+        }
+        while (isdigit(c)) {
+            ++exp;
+            ++it;
+            if (it == end) {
+                break;
+            }
+            c = *it;
+        }
+    }
+    // read 'small' part of the mantissa
+    if (c == '.') {
+        ++it;
+        if (it == end) {
+            return makeReturnValue();
+        }
+        c = *it;
+        while (remainingDigits > 0) {
+            if (!isdigit(c)) {
+                break;
+            }
+            --exp;
+            --remainingDigits;
+            mantissa *= 10;
+            mantissa += c - '0';
+            ++it;
+            if (it == end) {
+                return makeReturnValue();
+            }
+            c = *it;
+        }
+        if (isdigit(c)) {
+            // round correctly:
+            if (c - '0' >= 5) {
+                ++mantissa;
+            }
+        }
+        // skip the remaining digits:
+        it = std::find_if_not(it, end, isdigit);
+        if (it == end) {
+            return makeReturnValue();
+        }
+        c = *it;
+    }
+
+    // calculate the final exponent:
+    if (c == 'e' || c == 'E') {
+        ++it;
+        int tmp;
+        // we need to pass IntegerTag explicitly here because we are in a
+        // nested namespace. This shouldn't be required anywhere else
+        std::tie(tmp, it) = strTo<int, CharIterator, ValidationPolicy>(it, end, IntegerTag{});
+        exp += tmp;
+    }
+
+    // drop further whitespace:
+    std::tie(it, c) = dropSpaces(it, end);
+
+    return makeReturnValue();
+}
+
+template <typename CharIterator>
+std::tuple<CharIterator, char> dropSpaces(CharIterator it, CharIterator end) {
+    char c = 0;
+    while (it != end && std::isspace((c = *it))) {
+        ++it;
+    }
+    return std::make_tuple(it, c);
+}
+
+template <typename Integer>
+double powerOf10(Integer exp) {
+    if (exp < 0) {
+        return 1.0 / powerOf10(-exp);
+    }
+    switch (exp) {
+    case 0:
+        return 1;
+    case 1:
+        return 10;
+    case 2:
+        return 100;
+    case 3:
+        return 1000;
+    case 4:
+        return 10000;
+    case 5:
+        return 100000;
+    case 6:
+        return 1000000;
+    case 7:
+        return 10000000;
+    case 8:
+        return 100000000;
+    case 9:
+        return 1000000000;
+    default:
+        auto tmp = powerOf10(exp / 2);
+        if (exp % 2 == 0) {
+            return tmp * tmp;
+        } else {
+            return tmp * tmp * 10;
+        }
+    }
+}
+
+} // namespace Impl
+
+} // namespace Parsing
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_NUMBER_PARSING_HPP_

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

@@ -0,0 +1,57 @@
+/*
+ * NumericTools.hpp
+ *
+ *  Created on: 15.02.2013
+ *      Author: Christian Staudt (christian.staudt@kit.edu)
+ */
+
+#ifndef NETWORKIT_AUXILIARY_NUMERIC_TOOLS_HPP_
+#define NETWORKIT_AUXILIARY_NUMERIC_TOOLS_HPP_
+
+#include <limits>
+
+namespace Aux {
+
+/**
+ * Tools to deal with limited precision in numeric computations.
+ */
+namespace NumericTools {
+
+static constexpr double machineEpsilon = std::numeric_limits<double>::epsilon();
+
+static constexpr double acceptableError = 1e-12;
+
+template <typename T>
+bool willOverflow(const T &pX, const T &pValue, const T &pMax = std::numeric_limits<T>::max()) {
+    return pMax - pValue < pX;
+}
+
+template <typename T>
+bool willUnderflow(const T &pX, const T &pValue, const T &pMin = std::numeric_limits<T>::min()) {
+    return pMin + pValue > pX;
+}
+
+/**
+ * Test doubles for equality within a given error.
+ */
+bool equal(double x, double y, double error = acceptableError);
+
+/**
+ * Test doubles for equality within a given error.
+ */
+bool le(double x, double y, double error = acceptableError);
+
+/**
+ * Test doubles for equality within a given error.
+ */
+bool ge(double x, double y, double error = acceptableError);
+
+/**
+ * Test doubles for equality within the smallest possible error.
+ */
+bool logically_equal(double a, double b, double error_factor = 1.0);
+
+} /* namespace NumericTools */
+
+} // namespace Aux
+#endif // NETWORKIT_AUXILIARY_NUMERIC_TOOLS_HPP_

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

@@ -0,0 +1,56 @@
+/*
+ * Header which provides parallel STL implementations when available.
+ */
+#ifndef NETWORKIT_AUXILIARY_PARALLEL_HPP_
+#define NETWORKIT_AUXILIARY_PARALLEL_HPP_
+
+#include <atomic>
+#include <functional>
+
+#if ((defined(__GNUC__) || defined(__GNUG__)) \
+     && !(defined(__clang__) || defined(__INTEL_COMPILER))) \
+    && defined _OPENMP
+#include <parallel/algorithm>
+#else
+#define NETWORKIT_NO_PARALLEL_STL
+#include <algorithm>
+#endif
+
+namespace Aux {
+namespace Parallel {
+#ifdef NETWORKIT_NO_PARALLEL_STL
+using std::max_element;
+using std::sort;
+#else
+using __gnu_parallel::max_element;
+using __gnu_parallel::sort;
+#endif // NETWORKIT_NO_PARALLEL_STL
+
+template <typename ValueType, typename Comp>
+void atomic_set(std::atomic<ValueType> &target, const ValueType &input, Comp shallSet) {
+    // load current value
+    auto curValue = target.load(std::memory_order_relaxed);
+
+    do {
+        if (!shallSet(input, curValue))
+            break; // skip if shall not be set (anymore)
+        // set new value unless current value has been changed in the meantime, if current value has
+        // changed load it (so we can compare again)
+    } while (!target.compare_exchange_weak(curValue, input, std::memory_order_release,
+                                           std::memory_order_relaxed));
+}
+
+template <typename ValueType>
+void atomic_max(std::atomic<ValueType> &target, const ValueType &input) {
+    atomic_set(target, input, std::greater<ValueType>());
+}
+
+template <typename ValueType>
+void atomic_min(std::atomic<ValueType> &target, const ValueType &input) {
+    atomic_set(target, input, std::less<ValueType>());
+}
+
+} // namespace Parallel
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_PARALLEL_HPP_

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

@@ -0,0 +1,33 @@
+/*
+ * Parallelism.hpp
+ *
+ * Control functions related to parallelism.
+ *
+ *  Created on: 13.11.2013
+ *      Author: Christian Staudt (christian.staudt@kit.edu)
+ */
+
+#ifndef NETWORKIT_AUXILIARY_PARALLELISM_HPP_
+#define NETWORKIT_AUXILIARY_PARALLELISM_HPP_
+
+namespace Aux {
+
+/**
+ *  Set the number of threads available to the program.
+ */
+void setNumberOfThreads(int nThreads);
+
+/**
+ *
+ * @return The number of threads currently running.
+ */
+int getCurrentNumberOfThreads();
+
+/**
+ *
+ * @return The maximum number of threads available to the program.
+ */
+int getMaxNumberOfThreads();
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_PARALLELISM_HPP_

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

@@ -0,0 +1,252 @@
+/*
+ * PrioQueue.hpp
+ *
+ *  Created on: 02.03.2017
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_AUXILIARY_PRIO_QUEUE_HPP_
+#define NETWORKIT_AUXILIARY_PRIO_QUEUE_HPP_
+
+#include <cstdint>
+#include <limits>
+#include <set>
+#include <vector>
+
+#include <networkit/auxiliary/Log.hpp>
+
+namespace Aux {
+
+/**
+ * Priority queue with extract-min and decrease-key.
+ * The type Val takes on integer values between 0 and n-1.
+ * O(n log n) for construction, O(log n) for typical operations.
+ */
+template <class Key, class Value>
+class PrioQueue {
+private:
+    using ElemType = std::pair<Key, Value>;
+
+    std::set<ElemType> pqset; // TODO: would std::map work and simplify things?
+    std::vector<Key> mapValToKey;
+
+    const Key undefined = std::numeric_limits<Key>::max(); // TODO: make static
+
+protected:
+    /**
+     * Default constructor without functionality. Only here for derived classes!
+     */
+    PrioQueue() = default;
+
+    /**
+     * Removes key-value pair given by @a elem.
+     */
+    virtual void remove(const ElemType &elem);
+
+    /**
+     * @return current content of queue
+     */
+    virtual std::set<std::pair<Key, Value>> content() const;
+
+public:
+    /**
+     * Builds priority queue from the vector @a keys, values are indices
+     * of @a keys.
+     */
+    PrioQueue(const std::vector<Key> &keys);
+
+    /**
+     * Builds priority queue of the specified capacity @a capacity.
+     */
+    PrioQueue(uint64_t capacity);
+
+    /**
+     * Default destructor
+     */
+    virtual ~PrioQueue() = default;
+
+    /**
+     * Inserts key-value pair stored in @a elem.
+     */
+    virtual void insert(Key key, Value value);
+
+    /**
+     * Returns the @a n-th element in the priority queue.
+     */
+    virtual ElemType peekMin(size_t n = 0);
+
+    /**
+     * Removes the element with minimum key and returns it.
+     */
+    virtual ElemType extractMin();
+
+    /**
+     * 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.
+     */
+    virtual void changeKey(Key newKey, Value value);
+
+    /**
+     * @return Number of elements in PQ.
+     */
+    virtual uint64_t size() const;
+
+    /**
+     * @return Whether or not the PQ is empty.
+     */
+    virtual bool empty() const noexcept;
+
+    /**
+     * @return Whether or not the PQ contains the given value.
+     */
+    virtual bool contains(const Value &value) const;
+
+    /**
+     * Removes key-value pair given by value @a val.
+     */
+    virtual void remove(const Value &val);
+
+    /**
+     * Removes all the elements from the priority queue.
+     */
+    virtual void clear();
+
+    /**
+     * Iterates over all the elements of the priority queue and call @a handle
+     * (lambda closure).
+     */
+    template <typename L>
+    void forElements(L handle) const;
+
+    /**
+     * Iterates over all the elements of the priority queue while the condition
+     * is satisfied and call @a handle (lambda closure).
+     */
+    template <typename C, typename L>
+    void forElementsWhile(C condition, L handle) const;
+
+    /**
+     * DEBUGGING
+     */
+    virtual void print() {
+        DEBUG("num entries: ", mapValToKey.size());
+        for (uint64_t i = 0; i < mapValToKey.size(); ++i) {
+            DEBUG("key: ", mapValToKey[i], ", val: ", i, "\n");
+        }
+    }
+};
+
+template <class Key, class Value>
+Aux::PrioQueue<Key, Value>::PrioQueue(const std::vector<Key> &keys) {
+    mapValToKey.resize(keys.size());
+    uint64_t index = 0;
+    for (auto key : keys) {
+        insert(key, index);
+        ++index;
+    }
+}
+
+template <class Key, class Value>
+Aux::PrioQueue<Key, Value>::PrioQueue(uint64_t capacity) {
+    mapValToKey.resize(capacity);
+}
+
+template <class Key, class Value>
+void Aux::PrioQueue<Key, Value>::insert(Key key, Value value) {
+    if (value >= mapValToKey.size()) {
+        uint64_t doubledSize = 2 * mapValToKey.size();
+        assert(value < doubledSize);
+        mapValToKey.resize(doubledSize);
+    }
+    pqset.insert(std::make_pair(key, value));
+    mapValToKey.at(value) = key;
+}
+
+template <class Key, class Value>
+void Aux::PrioQueue<Key, Value>::remove(const ElemType &elem) {
+    remove(elem.second);
+}
+
+template <class Key, class Value>
+void Aux::PrioQueue<Key, Value>::remove(const Value &val) {
+    Key key = mapValToKey.at(val);
+    pqset.erase(std::make_pair(key, val));
+    mapValToKey.at(val) = undefined;
+}
+
+template <class Key, class Value>
+std::pair<Key, Value> Aux::PrioQueue<Key, Value>::peekMin(size_t n) {
+    assert(pqset.size() > n);
+    ElemType elem = *std::next(pqset.begin(), n);
+    return elem;
+}
+
+template <class Key, class Value>
+std::pair<Key, Value> Aux::PrioQueue<Key, Value>::extractMin() {
+    assert(!pqset.empty());
+    ElemType elem = (*pqset.begin());
+    remove(elem);
+    return elem;
+}
+
+template <class Key, class Value>
+void Aux::PrioQueue<Key, Value>::changeKey(Key newKey, Value value) {
+    // find and remove element with given key
+    remove(value);
+
+    // insert element with new value
+    insert(newKey, value);
+}
+
+template <class Key, class Value>
+uint64_t Aux::PrioQueue<Key, Value>::size() const {
+    return pqset.size();
+}
+
+template <class Key, class Value>
+bool Aux::PrioQueue<Key, Value>::empty() const noexcept {
+    return pqset.empty();
+}
+
+template <class Key, class Value>
+bool Aux::PrioQueue<Key, Value>::contains(const Value &value) const {
+    return value < mapValToKey.size() && mapValToKey.at(value) != undefined;
+}
+
+template <class Key, class Value>
+std::set<std::pair<Key, Value>> Aux::PrioQueue<Key, Value>::content() const {
+    return pqset;
+}
+
+template <class Key, class Value>
+void Aux::PrioQueue<Key, Value>::clear() {
+    pqset.clear();
+    auto capacity = mapValToKey.size();
+    mapValToKey.clear();
+    mapValToKey.resize(capacity);
+}
+
+template <class Key, class Value>
+template <typename L>
+void Aux::PrioQueue<Key, Value>::forElements(L handle) const {
+    for (auto it = pqset.begin(); it != pqset.end(); ++it) {
+        ElemType elem = *it;
+        handle(elem.first, elem.second);
+    }
+}
+
+template <class Key, class Value>
+template <typename C, typename L>
+void Aux::PrioQueue<Key, Value>::forElementsWhile(C condition, L handle) const {
+    for (auto it = pqset.begin(); it != pqset.end(); ++it) {
+        if (!condition()) {
+            break;
+        }
+        ElemType elem = *it;
+        handle(elem.first, elem.second);
+    }
+}
+
+} /* namespace Aux */
+#endif // NETWORKIT_AUXILIARY_PRIO_QUEUE_HPP_