@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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