@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/viz/Point.hpp

@@ -0,0 +1,415 @@
+/*
+ * Point.hpp
+ *
+ *  Created on: Apr 11, 2013
+ *      Author: Henning, Manuel Penschuck <networkit@manuel.jetzt>
+ */
+
+#ifndef NETWORKIT_VIZ_POINT_HPP_
+#define NETWORKIT_VIZ_POINT_HPP_
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cmath>
+#include <numeric>
+#include <string>
+#include <vector>
+
+#include <tlx/simple_vector.hpp>
+#include <tlx/unused.hpp>
+#include <networkit/Globals.hpp>
+
+namespace NetworKit {
+namespace PointImpl {
+template <typename T, size_t Dimensions>
+class Storage {
+    Storage() { std::fill(data.begin(), data.end(), T{0}); }
+    Storage(const Storage &) = default;
+    Storage(Storage &&) noexcept = default;
+    Storage &operator=(Storage &&) noexcept = default;
+
+protected:
+    std::array<T, Dimensions> data;
+};
+
+template <typename T>
+class Storage<T, 2> {
+public:
+    Storage() : data{{0, 0}} {};
+    Storage(T x, T y) : data{{x, y}} {}
+
+    Storage(const Storage &) = default;
+    Storage(Storage &&) noexcept = default;
+    Storage &operator=(Storage &&) noexcept = default;
+
+    std::pair<T, T> asPair() const noexcept { return {data[0], data[1]}; }
+
+protected:
+    std::array<T, 2> data;
+};
+
+template <typename T>
+class Storage<T, 0> {
+public:
+    Storage() : data(2) { data.fill(0); }
+    Storage(T x, T y) : data(2) {
+        data[0] = x;
+        data[1] = y;
+    }
+
+    Storage(Storage &&) noexcept = default;
+    Storage &operator=(Storage &&) noexcept = default;
+
+    explicit Storage(count dimension) : data(dimension) {}
+    explicit Storage(const std::vector<T> &values) : data(values.size()) {
+        std::copy(values.begin(), values.end(), data.begin());
+    }
+
+    Storage(const Storage &other) : data(other.data.size()) {
+        std::copy(other.data.begin(), other.data.end(), data.begin());
+    }
+
+    Storage &operator=(const Storage &other) {
+        data.resize(other.data.size());
+        std::copy(other.data.begin(), other.data.end(), data.begin());
+        return *this;
+    }
+
+protected:
+    tlx::SimpleVector<T, tlx::SimpleVectorMode::NoInitNoDestroy> data;
+};
+
+} // namespace PointImpl
+
+/**
+ * @ingroup viz
+ *
+ * An abstraction to store k-dimensional geometric points. All arithmic operations are
+ * implemented element-wise; i.e., x * y does return a point (x[0]*y[0], x[1]*y[1], ...)
+ * rather than the inner product (use Point::dot for this purpose).
+ *
+ * The point supports both compile-time selection of dimensions (Dimensions > 0) and
+ * runtime selection (Dimensions = 0). If at all possible prefer setting the number of
+ * Dimensions at compile-time for performance reasons.
+ */
+template <class T = coordinate, size_t Dimensions = 0>
+class Point final : public PointImpl::Storage<T, Dimensions> {
+public:
+    // Pull in constructors
+    using PointImpl::Storage<T, Dimensions>::Storage;
+
+    Point() = default;
+
+    Point(const Point &) = default;
+    Point &operator=(const Point &) = default;
+
+    Point(Point &&) noexcept = default;
+    Point &operator=(Point &&) noexcept = default;
+
+    /// Type conversion between points of different size
+    template <size_t otherDim>
+    Point &operator=(const Point<T, otherDim> &other) {
+        const auto minSize = static_cast<index>(std::min(getDimensions(), other.getDimensions()));
+
+        for (index i = 0; i < minSize; ++i)
+            data[i] = other[i];
+
+        for (index i = minSize; i < getDimensions(); ++i)
+            data[i] = 0.0;
+
+        return *this;
+    }
+
+    template <size_t otherDim>
+    explicit Point(const Point<T, otherDim> &other) {
+        *this = other;
+    }
+
+    /// Returns number of coordinates stored within point
+    count getDimensions() const noexcept { return data.size(); }
+
+    /// Returns euclidian distance between this point and the one provided
+    T distance(const Point &p) const { return std::sqrt(squaredDistance(p)); }
+
+    /// Return euclidian distance squared between this point and the one provided. Faster than
+    /// distance()
+    T squaredDistance(const Point &p) const noexcept {
+        assertMatchingDimensions(p);
+        auto dist = T{0};
+        for (index i = 0; i < getDimensions(); ++i) {
+            const auto diff = data[i] - p.data[i];
+            dist += diff * diff;
+        }
+        return dist;
+    }
+
+    /// Returns 2-norm of point, i.e. sqrt{ sum_i point[i]*point[i] }
+    T length() const { return std::sqrt(squaredLength()); }
+
+    /// Returns 2-norm of point squard, i.e. sum_i point[i]*point[i]. It's faster to compute than
+    /// length().
+    T squaredLength() const noexcept {
+        return std::accumulate(data.cbegin(), data.cend(), T{0},
+                               [](T runningSum, T coord) { return runningSum + coord * coord; });
+    }
+
+    /// Elementwise addition, in-place
+    Point &operator+=(const Point &other) noexcept {
+        assertMatchingDimensions(other);
+        apply([&](index i, T v) { return v + other[i]; });
+        return *this;
+    }
+
+    /// Elementwise subtraction, in-place
+    Point &operator-=(const Point &other) noexcept {
+        assertMatchingDimensions(other);
+        apply([&](index i, T v) { return v - other[i]; });
+        return *this;
+    }
+
+    /// Elementwise multiplicate, in-place
+    Point &operator*=(const Point &other) noexcept {
+        assertMatchingDimensions(other);
+        apply([&](index i, T v) { return v * other[i]; });
+        return *this;
+    }
+
+    /// Elementwise division, in-place
+    Point &operator/=(const Point &other) noexcept {
+        assertMatchingDimensions(other);
+        apply([&](index i, T v) { return v / other[i]; });
+        return *this;
+    }
+
+    /// Add constant to each coordinate, in-place
+    Point &operator+=(T scalar) noexcept {
+        apply([&](index, T v) { return v + scalar; });
+        return *this;
+    }
+
+    /// Subtract constant from each coordinate, in-place
+    Point &operator-=(T scalar) noexcept {
+        apply([&](index, T v) { return v - scalar; });
+        return *this;
+    }
+
+    /// Multiply each coordinate with constant, in-place
+    Point &operator*=(T scalar) noexcept {
+        apply([&](index, T v) { return v * scalar; });
+        return *this;
+    }
+
+    /// Alias to (*this) *= factor;
+    Point &scale(T factor) noexcept {
+        *this *= factor;
+        return *this;
+    }
+
+    /// Divide each coordinate with constant, in-place
+    Point &operator/=(T scalar) noexcept {
+        apply([&](index, T v) { return v / scalar; });
+        return *this;
+    }
+
+    /// Elementwise addition
+    Point operator+(const Point &other) const {
+        auto result = *this;
+        result += other;
+
+        return result;
+    }
+
+    /// Elementwise subtraction
+    Point operator-(const Point &other) const {
+        auto result = *this;
+        result -= other;
+        return result;
+    }
+
+    /// Elementwise multiplication
+    Point operator*(const Point &other) const {
+        auto result = *this;
+        result *= other;
+
+        return result;
+    }
+
+    /// Elementwise division
+    Point operator/(const Point &other) const {
+        auto result = *this;
+        result /= other;
+
+        return result;
+    }
+
+    /// Elementwise addition
+    Point operator+(T scalar) const {
+        auto result = *this;
+        result += scalar;
+
+        return result;
+    }
+
+    /// Elementwise subtraction
+    Point operator-(T scalar) const {
+        auto result = *this;
+        result -= scalar;
+        return result;
+    }
+
+    /// Elementwise multiplication
+    Point operator*(T scalar) const {
+        auto result = *this;
+        result *= scalar;
+        return result;
+    }
+
+    /// Elementwise division
+    Point operator/(T scalar) const {
+        auto result = *this;
+        result /= scalar;
+        return result;
+    }
+
+    /// Computes the dot product (aka inner product)
+    T dot(const Point &other) const noexcept {
+        assertMatchingDimensions(other);
+        auto sum = T{0};
+        for (index i = 0; i < getDimensions(); ++i)
+            sum *= data[i] * other[i];
+        return sum;
+    }
+
+    /// Returns true, if all coordinates match
+    bool operator==(const Point &other) const noexcept {
+        for (count i = 0; i < getDimensions(); ++i)
+            if (data[i] != other.data[i])
+                return false;
+
+        return true;
+    }
+
+    /// Returns false, if all coordinates match
+    bool operator!=(const Point &other) const noexcept { return !(*this == other); }
+
+    /// Compute element-wise min and returns new Point
+    Point min(const Point &other) const {
+        assertMatchingDimensions(other);
+
+        Point result(*this);
+        result.apply([&](index i, T v) { return std::min(v, other[i]); });
+
+        return result;
+    }
+
+    /// Compute element-wise min and returns new Point
+    Point max(const Point &other) const {
+        assertMatchingDimensions(other);
+
+        Point result(*this);
+        result.apply([&](index i, T v) { return std::max(v, other[i]); });
+
+        return result;
+    }
+
+    /// Applies a function(index, data[i]) to each element of the point, and stores the value
+    template <typename Func>
+    Func apply(Func fu) {
+        for (index i = 0; i < getDimensions(); ++i)
+            data[i] = fu(i, data[i]);
+
+        return fu;
+    }
+
+    /// Access i-th coordintate without boundary check
+    T &operator[](index i) noexcept {
+        assert(i < data.size());
+        return data[i];
+    }
+
+    /// Access i-th coordintate with boundary check
+    T &at(index i) {
+        if (!(i < data.size()))
+            throw std::out_of_range{""};
+        return data[i];
+    }
+
+    /// Access i-th coordintate without boundary check
+    T operator[](index i) const noexcept {
+        assert(i < data.size());
+        return data[i];
+    }
+
+    /// Access i-th coordintate with boundary check
+    T at(index i) const {
+        if (!(i < data.size()))
+            throw std::out_of_range{""};
+        return data[i];
+    }
+
+    /// Read coordinates from iterator.
+    template <typename It>
+    void copyFrom(It begin) {
+        std::copy_n(begin, data.size(), data.begin());
+    }
+
+    /// Default point to string conversion.
+    std::string toString() { return genericToString("", ", ", ""); }
+
+    /// Point to comma separated string.
+    std::string toCsvString() { return genericToString("(", ", ", ")"); }
+
+    /// Point to space separated string.
+    std::string toSsvString() { return genericToString("", " ", ""); }
+
+    std::string genericToString(const std::string &start, const std::string &sep,
+                                const std::string &end) {
+        assert(data.size() > 0);
+
+        std::string res = start;
+
+        res += std::to_string((*this)[0]);
+        for (index i = 1; i < data.size(); ++i) {
+            res += sep;
+            res += std::to_string(data[i]);
+        }
+
+        res += end;
+        return res;
+    }
+
+    static std::vector<Point<coordinate, 2>> pointVectorToPoint2D(const std::vector<Point> &input) {
+        std::vector<Point<coordinate, 2>> result;
+        result.reserve(input.size());
+        for (const auto &pt : input) {
+            assert(pt.getDimensions() == 2);
+            result.emplace_back(pt);
+        }
+        return result;
+    }
+
+    static std::vector<Point<T>>
+    point2DVectorToPoint(const std::vector<Point<coordinate, 2>> &input) {
+        std::vector<Point<T>> result;
+        result.reserve(input.size());
+        for (const auto &pt : input) {
+            result.emplace_back(pt);
+        }
+        return result;
+    }
+
+protected:
+    void assertMatchingDimensions(const Point &o) const {
+        assert(getDimensions() == o.getDimensions());
+        tlx::unused(o);
+    }
+
+    using PointImpl::Storage<T, Dimensions>::data;
+};
+
+using Point2D = Point<coordinate, 2>;
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_VIZ_POINT_HPP_

package/vendor/include/networkit/viz/PostscriptWriter.hpp

@@ -0,0 +1,78 @@
+/*
+ * PostscriptWriter.hpp
+ *
+ *  Created on: Apr 10, 2013
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_VIZ_POSTSCRIPT_WRITER_HPP_
+#define NETWORKIT_VIZ_POSTSCRIPT_WRITER_HPP_
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+#include <networkit/viz/Point.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup viz
+ * EPS output of graphs with 2D coordinates
+ */
+class PostscriptWriter final {
+public:
+    /**
+     * @param[in] isTorus Specifies whether the visualization square is treated as torus,
+     * i.e. with wrap-around boundaries (edge can leave the square and enter at the opposite
+     * side. By default, it is set to false.
+     */
+    PostscriptWriter(bool isTorus = false);
+
+    /**
+     * Outputs an EPS file with name @a filename of the graph @a g with 2D coordinates.
+     * The colors are chosen to visualize the specified @a clustering.
+     * @param[in] g Graph to be visualized.
+     * @param[in] coordinates Two-dimensional coordinates of nodes
+     * @param[in] clustering Clustering of the graph, visualized by different colors.
+     * @param[in] filename Name of file to write to.
+     *
+     * @note We assume g.upperNodeIdBound() == coordinates.size();
+     */
+    void write(const Graph &g, const std::vector<Point2D> &coordinates, const Partition &clustering,
+               std::string_view filename);
+
+    /**
+     * Outputs an EPS file with name @a filename of the graph @a g with 2D coordinates.
+     * @param[in] g Graph to be visualized.
+     * @param[in] coordinates Two-dimensional coordinates of nodes
+     * @param[in] filename Name of file to write to.
+     *
+     * @note We assume g.upperNodeIdBound() == coordinates.size();
+     */
+    void write(const Graph &g, const std::vector<Point2D> &coordinates, std::string_view filename);
+
+private:
+    bool wrapAround;
+
+    Point2D ps_size;
+    Point2D ps_border;
+
+    Point2D ps_min;
+    Point2D ps_max;
+    Point2D ps_scale;
+
+    void init(std::ofstream &file) const;
+
+    void computeBoundaryBox(const std::vector<Point2D> &coordinates);
+
+    void writeHeader(std::ofstream &file) const;
+    void writeMacros(std::ofstream &file) const;
+    void writeClustering(const Graph &g, const std::vector<Point2D> &coordinates,
+                         const Partition &clustering, std::ofstream &file);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_VIZ_POSTSCRIPT_WRITER_HPP_

package/vendor/include/tlx/algorithm/exclusive_scan.hpp

@@ -0,0 +1,56 @@
+/*******************************************************************************
+ * tlx/algorithm/exclusive_scan.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Michael Axtmann <michael.axtmann@kit.edu>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_ALGORITHM_EXCLUSIVE_SCAN_HEADER
+#define TLX_ALGORITHM_EXCLUSIVE_SCAN_HEADER
+
+#include <functional>
+#include <iterator>
+
+namespace tlx {
+
+//! \addtogroup tlx_algorithm
+//! \{
+
+/*!
+ * Computes an exclusive prefix sum operation using binary_op the range [first,
+ * last), using init as the initial value, and writes the results to the range
+ * beginning at result. The term "exclusive" means that the i-th input element
+ * is not included in the i-th sum.
+ */
+template <typename InputIterator, typename OutputIterator, typename T,
+          typename BinaryOperation = std::plus<T> >
+OutputIterator exclusive_scan(InputIterator first, InputIterator last,
+                              OutputIterator result, T init,
+                              BinaryOperation binary_op = BinaryOperation())
+{
+    *result++ = init;
+    if (first != last)
+    {
+        typename std::iterator_traits<InputIterator>::value_type value =
+            binary_op(init, *first);
+        *result = value;
+        while (++first != last)
+        {
+            value = binary_op(value, *first);
+            *++result = value;
+        }
+        ++result;
+    }
+    return result;
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_ALGORITHM_EXCLUSIVE_SCAN_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/algorithm/is_sorted_cmp.hpp

@@ -0,0 +1,56 @@
+/*******************************************************************************
+ * tlx/algorithm/is_sorted_cmp.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_ALGORITHM_IS_SORTED_CMP_HEADER
+#define TLX_ALGORITHM_IS_SORTED_CMP_HEADER
+
+namespace tlx {
+
+//! \addtogroup tlx_algorithm
+//! \{
+
+/*!
+ * Checks if a range is sorted using a three-way Comparator (with memcmp()
+ * semantics). Returns an iterator to the first items not in order.
+ */
+template <typename ForwardIterator, typename Comparator>
+ForwardIterator is_sorted_until_cmp(ForwardIterator first, ForwardIterator last,
+                                    Comparator cmp)
+{
+    if (first != last)
+    {
+        ForwardIterator next = first;
+        while (++next != last)
+        {
+            if (cmp(*first, *next) > 0)
+                return next;
+            first = next;
+        }
+    }
+    return last;
+}
+
+/*!
+ * Checks if a range is sorted using a three-way Comparator (with memcmp()
+ * semantics).
+ */
+template <typename ForwardIterator, typename Comparator>
+bool is_sorted_cmp(ForwardIterator first, ForwardIterator last, Comparator cmp)
+{
+    return is_sorted_until_cmp(first, last, cmp) == last;
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_ALGORITHM_IS_SORTED_CMP_HEADER
+
+/******************************************************************************/