@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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

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