@ladybugmem/icebug 0.1.0

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

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

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

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

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

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

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