@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,122 +0,0 @@
-/*
- * Random.hpp
- *
- *  Created on: 02.01.2014
- *      Author: FJW
- */
-
-#ifndef NETWORKIT_AUXILIARY_RANDOM_HPP_
-#define NETWORKIT_AUXILIARY_RANDOM_HPP_
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <random>
-#include <stdexcept>
-
-namespace Aux {
-
-/**
- * Provides several functions for random-numbers.
- *
- * All functions are guaranteed to be thread-safe.
- */
-namespace Random {
-
-/**
- * Sets the random seed that is used globally.
- * @param seed The seed value
- * @param useThreadId If the thread id shall be added to the seed value
- */
-void setSeed(uint64_t seed, bool useThreadId);
-
-/**
- * @returns a high-quality random seed for an URNG.
- */
-uint64_t getSeed();
-
-/**
- * @returns a reference to a seeded URNG that is thread_local.
- */
-std::mt19937_64 &getURNG();
-
-/**
- * @returns an integer distributed uniformly in an inclusive range;
- * @param upperBound the upper bound, default = UNINT64_T_MAX
- * @param lowerBound the lower bound, default = 0
- *
- * @warning Compared to obtaining a reference to a generator using
- * @ref getURNG() and then using a local std::uniform_int_distribution,
- * this method incurs a slow-down of up to 30%. Consider avoiding it
- * in hot sections.
- */
-uint64_t integer();
-uint64_t integer(uint64_t upperBound);
-uint64_t integer(uint64_t lowerBound, uint64_t upperBound);
-
-/**
- * @returns a double distributed uniformly in a half-open range: [lowerBound, upperBound)
- * @param upperBound default = 1.0
- * @param lowerBound default = 0.0
- *
- * @warning Compared to obtaining a reference to a generator using
- * @ref getURNG() and then using a local std::uniform_real_distribution,
- * this method incurs a slow-down of up to 30%. Consider avoiding it
- * in hot sections.
- */
-double real();
-double real(double upperBound);
-double real(double lowerBound, double upperBound);
-
-/**
- * @returns a double distributed uniformly in the range [0, 1]
- * @note this differs from real() in returning a value in a closed instead of a half-open range.
- *
- * @warning Compared to obtaining a reference to a generator using
- * @ref getURNG() and then using a local std::uniform_int_distribution,
- * this method incurs a slow-down of up to 30%. Consider avoiding it
- * in hot sections.
- */
-double probability();
-
-/**
- * @returns a size_t in the range [0, max - 1] that can for example be used to
- * access a random element of a container.
- */
-std::size_t index(std::size_t max);
-
-/**
- * @returns a uniform random choice from an indexable container of elements.
- */
-template <typename Container>
-typename Container::const_reference choice(const Container &container) {
-    return container[index(container.size())];
-}
-
-/**
- * @returns a weighted random choice from a vector of elements with given weights.
- */
-template <typename Element>
-const Element &weightedChoice(const std::vector<std::pair<Element, double>> &weightedElements) {
-    if (weightedElements.empty())
-        throw std::runtime_error("Random::weightedChoice: input size equal to 0");
-    double total = 0.0;
-    for (const auto &entry : weightedElements) {
-        assert(entry.second >= 0.0 && "This algorithm only works with non-negative weights");
-        total += entry.second;
-    }
-    double r = Aux::Random::real(total);
-    for (const auto &entry : weightedElements) {
-        if (r < entry.second) {
-            return entry.first;
-        }
-        r -= entry.second;
-    }
-    throw std::runtime_error(
-        "Random::weightedChoice: should never get here"); // should never get here
-}
-
-} // namespace Random
-} // namespace Aux
-
-#endif // NETWORKIT_AUXILIARY_RANDOM_HPP_

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

@@ -1,72 +0,0 @@
-/*
- * SetIntersector.hpp
- *
- *  Created on: 14.05.2014
- *      Author: Henning
- */
-
-#ifndef NETWORKIT_AUXILIARY_SET_INTERSECTOR_HPP_
-#define NETWORKIT_AUXILIARY_SET_INTERSECTOR_HPP_
-
-#include <cstdint>
-#include <set>
-#include <vector>
-
-namespace Aux {
-
-/**
- * Provides set intersection for sets with entries from 0 to an upper bound (exclusive).
- * Preprocessing time: Linear time for object creation (creates a bit vector of size upperBound.
- * Query time: O(|A|+|B|) for two sets A and B.
- * Space complexity: upperBound + 64 bits.
- */
-template <class T>
-class SetIntersector {
-public:
-    /**
-     * @param upperBound Exclusive upper bound for IDs of set members.
-     */
-    SetIntersector(T upperBound);
-
-    /**
-     * @return Intersection of sets provided in @a A and @a B.
-     */
-    std::set<T> intersect(const std::vector<T> &A, const std::vector<T> &B);
-
-private:
-    std::vector<bool> bv;
-    uint64_t n;
-};
-
-} // namespace Aux
-
-template <class T>
-inline Aux::SetIntersector<T>::SetIntersector(T upperBound) : n(upperBound) {
-    bv.resize(n, false);
-}
-
-template <class T>
-inline std::set<T> Aux::SetIntersector<T>::intersect(const std::vector<T> &A,
-                                                     const std::vector<T> &B) {
-    const std::vector<T> &smaller = (A.size() <= B.size()) ? A : B;
-    const std::vector<T> &larger = (A.size() <= B.size()) ? B : A;
-
-    for (auto entry : smaller) {
-        bv[entry] = true;
-    }
-
-    std::set<T> result;
-    for (auto entry : larger) {
-        if (bv[entry]) {
-            result.insert(entry);
-        }
-    }
-
-    for (auto entry : smaller) {
-        bv[entry] = false;
-    }
-
-    return result;
-}
-
-#endif // NETWORKIT_AUXILIARY_SET_INTERSECTOR_HPP_

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

@@ -1,39 +0,0 @@
-#ifndef NETWORKIT_AUXILIARY_SIGNAL_HANDLING_HPP_
-#define NETWORKIT_AUXILIARY_SIGNAL_HANDLING_HPP_
-
-#include <cstdint>
-#include <exception>
-
-namespace Aux {
-
-/**
- * Signal handler class used to support CTRL+c user interrupts.
- * This class works by registering a interrupt handler during its lifetime; to check if an interrupt
- * has been received or to immediately stop running a (long-running) algorithm, use the
- * `assureRunning` or `isRunning` member functions.
- * @note Make sure to delete this object when it is no longer required to free up the interrupt
- * handler again for other code such as the python runtime!
- */
-class SignalHandler {
-public:
-    SignalHandler();
-
-    ~SignalHandler();
-
-    void assureRunning();
-
-    bool isRunning();
-
-    /**
-     * Special Exception to indicate that a SIGINT has been received.
-     */
-    class InterruptException : public std::exception {
-    public:
-        InterruptException() : std::exception() {}
-        const char *what() const noexcept override { return "Received CTRL+C/SIGINT"; }
-    };
-};
-
-} // namespace Aux
-
-#endif // NETWORKIT_AUXILIARY_SIGNAL_HANDLING_HPP_

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

@@ -1,128 +0,0 @@
-/*
- * SortedList.hpp
- *
- *  Created on: 21.09.2018
- *      Author: Eugenio Angriman
- */
-
-#ifndef NETWORKIT_AUXILIARY_SORTED_LIST_HPP_
-#define NETWORKIT_AUXILIARY_SORTED_LIST_HPP_
-
-#include <algorithm>
-#include <vector>
-
-namespace Aux {
-/*
- * Keeps a sorted list of pairs with at most k elements.
- * If more than k elements are inserted, the elements with smallest value are
- * removed. The list is implemented on top of vector, thus the insert operation
- * takes O(k) time.
- *
- * Warning: this sorted list was designed for the Kadabra algorithm; we assume
- * that all the newly inserted elements have a value that is greater or equal
- * to 0 if not already present in the list, or greater or equal their previous
- * value.
- * TODO: generalize this data structure.
- */
-class SortedList {
-private:
-    std::vector<std::pair<uint64_t, double>> elements;
-    std::vector<uint64_t> position;
-    uint64_t virtualSize;
-    const uint64_t size;
-    const uint64_t maxKey;
-
-public:
-    /**
-     * Creates a SortedList of size @a size accepting key values from 0 to
-     * @a maxKey.
-     */
-    SortedList(uint64_t size, uint64_t maxKey);
-
-    /**
-     * Insert a key-value element.
-     */
-    void insert(uint64_t newElement, double newValue);
-
-    /**
-     * Returns the value at position @a i in the ranking.
-     */
-    double getValue(const uint64_t i) const { return elements[i].second; }
-
-    /**
-     * Returns the element at position @a i in the ranking.
-     */
-    uint64_t getElement(const uint64_t i) const { return elements[i].first; }
-
-    /**
-     * Returns the number of elements stored in the list.
-     */
-    uint64_t getSize() const { return virtualSize; }
-
-    /**
-     * Removes all the elements in the list.
-     */
-    void clear();
-};
-
-inline SortedList::SortedList(const uint64_t size, const uint64_t maxKey)
-    : size(size), maxKey(maxKey) {
-    if (maxKey < size) {
-        throw std::runtime_error("maxKey must be bigger than the size.");
-    }
-    clear();
-}
-
-inline void SortedList::clear() {
-    elements.resize(size);
-    position.resize(maxKey);
-    uint64_t i;
-    for (i = 0; i < size; ++i) {
-        elements[i] = std::make_pair(i, 0.);
-        position[i] = i;
-    }
-    for (i = size; i < maxKey; ++i) {
-        position[i] = i;
-    }
-    virtualSize = 0;
-}
-
-inline void SortedList::insert(const uint64_t newElement, const double newValue) {
-    uint64_t ub = std::upper_bound(elements.begin(), elements.begin() + virtualSize, newValue,
-                                   [&](const double val, const std::pair<uint64_t, double> pair) {
-                                       return val > pair.second;
-                                   })
-                  - elements.begin();
-
-    uint64_t oldPos;
-    // We assume that if the same key is inserted again, its value will be
-    // greater than before (i.e., oldPos >= ub).
-    if (ub < size) {
-        oldPos = std::min(position[newElement], size - 1);
-        if (position[newElement] < size) {
-            assert(elements[ub].second <= newValue);
-        }
-        if (virtualSize < size && oldPos >= virtualSize) {
-            ++virtualSize;
-        }
-
-        if (ub < oldPos) {
-            std::rotate(elements.begin() + ub, elements.begin() + oldPos,
-                        elements.begin() + oldPos + 1);
-
-            if (oldPos == size - 1) {
-                ++position[elements[ub].first];
-            }
-
-            elements[ub] = std::make_pair(newElement, newValue);
-            for (auto it = elements.begin() + ub + 1; it < elements.begin() + oldPos + 1; ++it) {
-                ++position[(*it).first];
-            }
-        } else {
-            elements[ub].second = newValue;
-        }
-    }
-}
-} // namespace Aux
-
-#endif // NETWORKIT_AUXILIARY_SORTED_LIST_HPP_

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

@@ -1,215 +0,0 @@
-/*
- * SparseVector.hpp
- *
- * Created: 2019-10-15
- * Author: Armin Wiebigke
- */
-#ifndef NETWORKIT_AUXILIARY_SPARSE_VECTOR_HPP_
-#define NETWORKIT_AUXILIARY_SPARSE_VECTOR_HPP_
-
-#include <algorithm>
-#include <cassert>
-#include <vector>
-
-#include <networkit/Globals.hpp>
-
-namespace NetworKit {
-
-/**
- * A vector that imitates a map with unsigned integer keys.
- * This class has faster access than a map, but needs space linear in the maximum key value.
- */
-template <typename T>
-class SparseVector {
-public:
-    SparseVector();
-
-    /**
-     * Construct an empty vector. Empty values are created using the default constructor.
-     * @param size upper bound for the maximum usable index
-     */
-    explicit SparseVector(index size);
-
-    /**
-     * Construct an empty vector.
-     * @param size upper bound for the maximum usable index
-     * @param emptyValue value used for empty entries
-     */
-    SparseVector(index size, T emptyValue);
-
-    /**
-     * Resize the vector so that indexes up to size-1 can be used.
-     */
-    void setUpperBound(index size);
-
-    /**	 *
-     * @return the upper bound of the indexes that can be used
-     */
-    index upperBound() const;
-
-    /**
-     * @return the number of inserted elements.
-     */
-    count size() const;
-
-    /**
-     * Insert a value at a given position.
-     * @param i index where the value is inserted
-     * @param value
-     */
-    void insert(index i, T value);
-
-    /**
-     * Access operator. Before accessing an element, insert it by using the insert() method.
-     */
-    T &operator[](index i);
-
-    /**
-     * Const access operator. Before accessing an element, insert it by using the insert() method.
-     */
-    const T &operator[](index i) const;
-
-    /**
-     * Returns true iff an element was previously inserted at the given index.
-     * @param idx
-     */
-    bool indexIsUsed(index idx);
-
-    /**
-     * Inserts value at position i, or replaces the value if previously inserted
-     * @param i
-     * @param value
-     */
-    void insertOrSet(index i, T value);
-
-    /**
-     * Remove all indexes for which the value is set to the emptyValue.
-     */
-    void removeUnusedIndexes() {
-        auto new_end = std::remove_if(usedIndexes.begin(), usedIndexes.end(),
-                                      [&](index i) { return data[i] == emptyValue; });
-        usedIndexes.erase(new_end, usedIndexes.end());
-    }
-
-    /**
-     * Reset all values to the default value, so it is "empty". The upper bound is not changed.
-     */
-    void reset();
-
-    /**
-     * Clear the vector, setting the upper bound of usable indexes to 0.
-     */
-    void clear();
-
-    /**
-     * Reallocate the datastructure if size exceeds current upper bound
-     * This is different from setUpperBound() since we want to make sure both usedIndexes and data
-     * are allocated on the socket of the calling thread
-     * @param size
-     * @param emptyValue new emptyValue
-     */
-    void resize(size_t size, T emptyValue);
-
-    /**
-     * Applies the given lambda to each inserted index and associated value
-     * @tparam ElementHandler
-     * @param lambda
-     */
-    template <typename ElementHandler>
-    void forElements(ElementHandler &&lambda) {
-        for (index i : usedIndexes) {
-            lambda(i, data[i]);
-        }
-    }
-
-private:
-    std::vector<T> data;
-    std::vector<index> usedIndexes;
-    T emptyValue;
-};
-
-template <typename T>
-SparseVector<T>::SparseVector() : emptyValue(T{}) {}
-
-template <typename T>
-SparseVector<T>::SparseVector(count size) : SparseVector(size, T{}) {}
-
-template <typename T>
-SparseVector<T>::SparseVector(count size, T emptyValue)
-    : data(size, emptyValue), emptyValue(emptyValue) {}
-
-template <typename T>
-void SparseVector<T>::reset() {
-    for (index i : usedIndexes) {
-        data[i] = emptyValue;
-    }
-    usedIndexes.clear();
-}
-
-template <typename T>
-void SparseVector<T>::insert(index i, T value) {
-    assert(data[i] == emptyValue);
-    usedIndexes.push_back(i);
-    data[i] = std::move(value);
-}
-
-template <typename T>
-T &SparseVector<T>::operator[](index i) {
-    return data[i];
-}
-
-template <typename T>
-const T &NetworKit::SparseVector<T>::operator[](NetworKit::index i) const {
-    assert(i < data.size());
-    return data[i];
-}
-
-template <typename T>
-void SparseVector<T>::setUpperBound(index size) {
-    data.resize(size, emptyValue);
-}
-
-template <typename T>
-index SparseVector<T>::upperBound() const {
-    return data.size();
-}
-
-template <typename T>
-count SparseVector<T>::size() const {
-    return usedIndexes.size();
-}
-
-template <typename T>
-void NetworKit::SparseVector<T>::clear() {
-    usedIndexes.clear();
-    usedIndexes.shrink_to_fit();
-    data.clear();
-    data.shrink_to_fit();
-}
-
-template <typename T>
-void NetworKit::SparseVector<T>::resize(size_t size, T emptyValue) {
-    if (size > upperBound()) {
-        this->emptyValue = emptyValue;
-        data = std::vector<T>(size, this->emptyValue);
-        usedIndexes = std::vector<index>();
-    }
-}
-
-template <typename T>
-bool NetworKit::SparseVector<T>::indexIsUsed(index idx) {
-    return data[idx] != emptyValue;
-}
-
-template <typename T>
-void NetworKit::SparseVector<T>::insertOrSet(NetworKit::index i, T value) {
-    if (!indexIsUsed(i)) {
-        insert(i, value);
-    } else {
-        data[i] = value;
-    }
-}
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_AUXILIARY_SPARSE_VECTOR_HPP_

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

@@ -1,23 +0,0 @@
-#ifndef NETWORKIT_AUXILIARY_SPIN_LOCK_HPP_
-#define NETWORKIT_AUXILIARY_SPIN_LOCK_HPP_
-
-#include <atomic>
-
-namespace Aux {
-
-class Spinlock {
-public:
-    void lock() {
-        while (spinner.test_and_set(std::memory_order_acquire)) {
-            /* spin */
-        }
-    }
-    void unlock() { spinner.clear(std::memory_order_release); }
-
-private:
-    std::atomic_flag spinner = ATOMIC_FLAG_INIT;
-};
-
-} // namespace Aux
-
-#endif // NETWORKIT_AUXILIARY_SPIN_LOCK_HPP_