@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/generators/quadtree/Quadtree.hpp

@@ -0,0 +1,232 @@
+/*
+ * Quadtree.hpp
+ *
+ *  Created on: 21.05.2014
+ *      Author: Moritz v. Looz
+ */
+
+#ifndef NETWORKIT_GENERATORS_QUADTREE_QUADTREE_HPP_
+#define NETWORKIT_GENERATORS_QUADTREE_QUADTREE_HPP_
+
+#include <cmath>
+#include <memory>
+#include <omp.h>
+#include <vector>
+
+#include <networkit/auxiliary/Parallel.hpp>
+#include <networkit/generators/quadtree/QuadNode.hpp>
+#include <networkit/geometric/HyperbolicSpace.hpp>
+
+namespace NetworKit {
+
+template <class T, bool poincare = true>
+class Quadtree final {
+    friend class QuadTreeGTest;
+
+public:
+    Quadtree() {
+        root = QuadNode<T, poincare>();
+        this->maxRadius = 1;
+    }
+
+    /**
+     * @param maxR Radius of the managed area. Must be smaller than 1.
+     * @param theoreticalSplit If true, split cells to get the same area in each child cell. Default
+     * is false
+     * @param alpha dispersion Parameter of the point distribution. Only has an effect if
+     * theoretical split is true
+     * @param capacity How many points can inhabit a leaf cell before it is split up?
+     *
+     */
+    Quadtree(double maxR, bool theoreticalSplit = false, double alpha = 1, count capacity = 1000,
+             double balance = 0.5) {
+        root =
+            QuadNode<T, poincare>(0, 0, 2 * PI, maxR, capacity, theoreticalSplit, alpha, balance);
+        this->maxRadius = maxR;
+    }
+
+    Quadtree(const vector<double> &angles, const vector<double> &radii, const vector<T> &content,
+             double stretch, bool theoreticalSplit = false, double alpha = 1, count capacity = 1000,
+             double balance = 0.5) {
+        const count n = angles.size();
+        assert(angles.size() == radii.size());
+        assert(radii.size() == content.size());
+        double R = stretch * HyperbolicSpace::hyperbolicAreaToRadius(n);
+        double r = HyperbolicSpace::hyperbolicRadiusToEuclidean(R);
+        root = QuadNode<T>(0, 0, 2 * PI, r, capacity, theoreticalSplit, alpha, balance);
+        maxRadius = r;
+        for (index i = 0; i < n; i++) {
+            assert(content[i] < n);
+            root.addContent(content[i], angles[i], radii[i]);
+        }
+    }
+
+    /**
+     * @param newcomer content to be added at point x
+     * @param angle angular coordinate of x
+     * @param R radial coordinate of x
+     */
+    void addContent(T newcomer, double angle, double r) { root.addContent(newcomer, angle, r); }
+
+    /**
+     * @param newcomer content to be removed at point x
+     * @param angle angular coordinate of x
+     * @param R radial coordinate of x
+     */
+    bool removeContent(T toRemove, double angle, double r) {
+        return root.removeContent(toRemove, angle, r);
+    }
+
+    /**
+     * Get all elements, regardless of position
+     *
+     * @return vector<T> of elements
+     */
+    vector<T> getElements() const { return root.getElements(); }
+
+    void extractCoordinates(vector<double> &anglesContainer, vector<double> &radiiContainer) const {
+        root.getCoordinates(anglesContainer, radiiContainer);
+    }
+
+    /**
+     * Get elements whose hyperbolic distance to the query point is less than the hyperbolic
+     * distance
+     *
+     * @param circleCenter Cartesian coordinates of the query circle's center
+     * @param hyperbolicRadius Radius of the query circle
+     */
+    vector<T> getElementsInHyperbolicCircle(Point2DWithIndex<double> circleCenter,
+                                            double hyperbolicRadius) const {
+        vector<T> circleDenizens;
+        getElementsInHyperbolicCircle(circleCenter, hyperbolicRadius, circleDenizens);
+        return circleDenizens;
+    }
+
+    void getElementsInHyperbolicCircle(const Point2DWithIndex<double> circleCenter,
+                                       const double hyperbolicRadius, const bool suppressLeft,
+                                       vector<T> &circleDenizens) const {
+        assert(circleDenizens.empty());
+        double cc_phi, cc_r;
+        HyperbolicSpace::cartesianToPolar(circleCenter, cc_phi, cc_r);
+        // Transform hyperbolic circle into Euclidean circle
+        double minPhi, maxPhi, radius, r_e;
+        HyperbolicSpace::getEuclideanCircle(cc_r, hyperbolicRadius, r_e, radius);
+        Point2DWithIndex<double> center = HyperbolicSpace::polarToCartesian(cc_phi, r_e);
+        double minR = r_e - radius;
+        double maxR = r_e + radius;
+        if (maxR > 1)
+            maxR = 1;
+        if (minR < 0) {
+            maxR = std::max(std::abs(minR), maxR);
+            minR = 0;
+            minPhi = 0;
+            maxPhi = 2 * PI;
+        } else {
+            double spread = std::asin(radius / r_e);
+            minPhi = cc_phi - spread;
+            maxPhi = cc_phi + spread;
+            /**
+             * If the circle overlaps the 2\pi line, we have to make two separate calls and collect
+             */
+        }
+
+        if (suppressLeft)
+            minPhi = cc_phi;
+        /**
+         * get Elements in Euclidean circle
+         */
+
+        bool wraparound = false;
+        root.getElementsInEuclideanCircle(center, radius, circleDenizens, minPhi, maxPhi, minR,
+                                          maxR);
+        if (minPhi < 0) {
+            root.getElementsInEuclideanCircle(center, radius, circleDenizens, 2 * PI + minPhi,
+                                              2 * PI, minR, maxR);
+            wraparound = true;
+        }
+        if (maxPhi > 2 * PI) {
+            root.getElementsInEuclideanCircle(center, radius, circleDenizens, 0, maxPhi - 2 * PI,
+                                              minR, maxR);
+            wraparound = true;
+        }
+
+        for (T denizen : circleDenizens) {
+            if (denizen >= size()) {
+                DEBUG("Content ", denizen, " found in quadtree of size ", size(), ", as one of ",
+                      circleDenizens.size(), " neighbors.");
+            }
+        }
+
+        // we have sort(deg(v)) here! This is not good, but does not make the asymptotical
+        // complexity of O(deg(v) log n) worse.
+        if (wraparound) {
+            Aux::Parallel::sort(circleDenizens.begin(), circleDenizens.end());
+            auto newend = unique(circleDenizens.begin(), circleDenizens.end());
+            count toRemove = circleDenizens.end() - newend;
+            count remaining = newend - circleDenizens.begin();
+            if (toRemove > 0) {
+                DEBUG("Removing, ", toRemove, " duplicate entries, keeping ", remaining);
+                circleDenizens.resize(remaining);
+            }
+        }
+
+        for (T denizen : circleDenizens) {
+            if (denizen >= size())
+                DEBUG("Content ", denizen, " found in quadtree of size ", size(), ", as one of ",
+                      circleDenizens.size(), " neighbors, after sorting");
+        }
+    }
+
+    void getElementsInHyperbolicCircle(const Point2DWithIndex<double> circleCenter,
+                                       const double hyperbolicRadius,
+                                       vector<T> &circleDenizens) const {
+        getElementsInHyperbolicCircle(circleCenter, hyperbolicRadius, false, circleDenizens);
+    }
+
+    count getElementsProbabilistically(Point2DWithIndex<double> euQuery,
+                                       std::function<double(double)> prob,
+                                       vector<T> &circleDenizens) {
+        return root.getElementsProbabilistically(euQuery, prob, false, circleDenizens);
+    }
+
+    count getElementsProbabilistically(Point2DWithIndex<double> euQuery,
+                                       std::function<double(double)> prob, bool suppressLeft,
+                                       vector<T> &circleDenizens) {
+        return root.getElementsProbabilistically(euQuery, prob, suppressLeft, circleDenizens);
+    }
+
+    void recount() { root.recount(); }
+
+    count size() const { return root.size(); }
+
+    count height() const { return root.height(); }
+
+    count countLeaves() const { return root.countLeaves(); }
+
+    index indexSubtree(index nextID) { return root.indexSubtree(nextID); }
+
+    index getCellID(double phi, double r) const { return root.getCellID(phi, r); }
+
+    double getMaxRadius() const { return maxRadius; }
+
+    void reindex() {
+#pragma omp parallel
+        {
+#pragma omp single nowait
+            { root.reindex(0); }
+        }
+    }
+
+    /**
+     * trims the vectors used to hold the content in the leaf cells. Reduces memory usage, makes
+     * changes slower
+     */
+    void trim() { root.trim(); }
+
+private:
+    QuadNode<T, poincare> root;
+    double maxRadius;
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_GENERATORS_QUADTREE_QUADTREE_HPP_

package/vendor/include/networkit/generators/quadtree/QuadtreeCartesianEuclid.hpp

@@ -0,0 +1,149 @@
+/*
+ * Quadtree.hpp
+ *
+ *  Created on: 21.05.2014
+ *      Author: Moritz v. Looz
+ */
+
+#ifndef NETWORKIT_GENERATORS_QUADTREE_QUADTREE_CARTESIAN_EUCLID_HPP_
+#define NETWORKIT_GENERATORS_QUADTREE_QUADTREE_CARTESIAN_EUCLID_HPP_
+
+#include <cmath>
+#include <memory>
+#include <omp.h>
+#include <vector>
+
+#include <networkit/generators/quadtree/QuadNodeCartesianEuclid.hpp>
+
+namespace NetworKit {
+
+template <class T>
+class QuadtreeCartesianEuclid final {
+    friend class QuadTreeCartesianEuclidGTest;
+
+public:
+    /**
+     * @param lower Minimal coordinates of region
+     * @param upper Maximal coordinates of region (excluded)
+     * @param capacity Number of points a leaf cell can store before splitting
+     * @param splitTheoretical Whether to split in a theoretically optimal way or in a way to
+     * decrease measured running times
+     *
+     */
+    QuadtreeCartesianEuclid(Point<double> lower = Point<double>(0.0, 0.0),
+                            Point<double> upper = Point<double>(1.0, 1.0),
+                            bool theoreticalSplit = false, count capacity = 1000) {
+        assert(lower.getDimensions() == upper.getDimensions());
+        root = QuadNodeCartesianEuclid<T>(lower, upper, capacity, theoreticalSplit);
+        this->lower = lower;
+        this->upper = upper;
+    }
+
+    QuadtreeCartesianEuclid(const vector<Point<double>> &positions, const vector<T> &content,
+                            bool theoreticalSplit = false, count capacity = 1000) {
+        const count n = positions.size();
+        assert(content.size() == n);
+        assert(n > 0);
+
+        this->dimension = positions[0].getDimensions();
+        vector<double> lowerValue(dimension);
+        vector<double> upperValue(dimension);
+        for (index d = 0; d < dimension; d++) {
+            lowerValue[d] = positions[0].at(d);
+            upperValue[d] = positions[0].at(d);
+        }
+
+        for (Point<double> pos : positions) {
+            assert(pos.getDimensions() == dimension);
+            for (index d = 0; d < dimension; d++) {
+                if (pos[d] < lowerValue[d])
+                    lowerValue[d] = pos[d];
+                if (pos[d] > upperValue[d])
+                    upperValue[d] = pos[d];
+            }
+        }
+
+        // the upper limit is open, so it needs to be above the points
+        for (index d = 0; d < dimension; d++) {
+            upperValue[d] = std::nextafter(upperValue[d], std::numeric_limits<double>::max());
+        }
+        this->lower = Point<double>(lowerValue);
+        this->upper = Point<double>(upperValue);
+
+        root = QuadNodeCartesianEuclid<T>(lower, upper, capacity, theoreticalSplit);
+        for (index i = 0; i < n; i++) {
+            assert(content[i] < n);
+            root.addContent(content[i], positions[i]);
+        }
+    }
+
+    /**
+     * @param newcomer content to be added at point x
+     * @param angle angular coordinate of x
+     * @param R radial coordinate of x
+     */
+    void addContent(T newcomer, Point<double> pos) { root.addContent(newcomer, pos); }
+
+    /**
+     * @param newcomer content to be removed at point x
+     * @param angle angular coordinate of x
+     * @param R radial coordinate of x
+     */
+    bool removeContent(T toRemove, Point<double> pos) { return root.removeContent(toRemove, pos); }
+
+    /**
+     * Get all elements, regardless of position
+     *
+     * @return vector<T> of elements
+     */
+    vector<T> getElements() const { return root.getElements(); }
+
+    void extractCoordinates(vector<Point<double>> &posContainer) const {
+        root.getCoordinates(posContainer);
+    }
+
+    void getElementsInEuclideanCircle(const Point<double> circleCenter, const double radius,
+                                      vector<T> &circleDenizens) const {
+        root.getElementsInEuclideanCircle(circleCenter, radius, circleDenizens);
+    }
+
+    template <typename L>
+    count getElementsProbabilistically(Point<double> euQuery, L prob, vector<T> &circleDenizens) {
+        return root.getElementsProbabilistically(euQuery, prob, circleDenizens);
+    }
+
+    void recount() { root.recount(); }
+
+    count size() const { return root.size(); }
+
+    count height() const { return root.height(); }
+
+    count countLeaves() const { return root.countLeaves(); }
+
+    index indexSubtree(index nextID) { return root.indexSubtree(nextID); }
+
+    index getCellID(Point<double> pos) const { return root.getCellID(pos); }
+
+    void reindex() {
+#pragma omp parallel
+        {
+#pragma omp single nowait
+            { root.reindex(0); }
+        }
+    }
+
+    /**
+     * trims the vectors used to hold the content in the leaf cells. Reduces memory usage, makes
+     * changes slower
+     */
+    void trim() { root.trim(); }
+
+private:
+    QuadNodeCartesianEuclid<T> root;
+    Point<double> lower;
+    Point<double> upper;
+    count dimension;
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_GENERATORS_QUADTREE_QUADTREE_CARTESIAN_EUCLID_HPP_

package/vendor/include/networkit/generators/quadtree/QuadtreePolarEuclid.hpp

@@ -0,0 +1,143 @@
+/*
+ * Quadtree.hpp
+ *
+ *  Created on: 21.05.2014
+ *      Author: Moritz v. Looz
+ */
+
+#ifndef NETWORKIT_GENERATORS_QUADTREE_QUADTREE_POLAR_EUCLID_HPP_
+#define NETWORKIT_GENERATORS_QUADTREE_QUADTREE_POLAR_EUCLID_HPP_
+
+#include <cmath>
+#include <memory>
+#include <omp.h>
+#include <vector>
+
+#include <networkit/generators/quadtree/QuadNodePolarEuclid.hpp>
+
+namespace NetworKit {
+
+template <class T>
+class QuadtreePolarEuclid final {
+    friend class QuadTreePolarEuclidGTest;
+
+public:
+    QuadtreePolarEuclid() {
+        root = QuadNodePolarEuclid<T>();
+        this->maxRadius = 1;
+    }
+
+    /**
+     * @param maxR Radius of the managed area. Must be smaller than 1.
+     * @param theoreticalSplit If true, split cells to get the same area in each child cell. Default
+     * is false
+     * @param alpha dispersion Parameter of the point distribution. Only has an effect if
+     * theoretical split is true
+     * @param capacity How many points can inhabit a leaf cell before it is split up?
+     *
+     */
+    QuadtreePolarEuclid(double maxR, bool theoreticalSplit = false, double alpha = 1,
+                        count capacity = 1000, double balance = 0.5) {
+        root = QuadNodePolarEuclid<T>(0, 0, 2 * PI, maxR, capacity, 0, theoreticalSplit, alpha,
+                                      balance);
+        this->maxRadius = maxR;
+    }
+
+    QuadtreePolarEuclid(const vector<double> &angles, const vector<double> &radii,
+                        const vector<T> &content, bool theoreticalSplit = false,
+                        count capacity = 1000, double balance = 0.5) {
+        const count n = angles.size();
+        assert(angles.size() == radii.size());
+        assert(radii.size() == content.size());
+        maxRadius = 0;
+        for (double radius : radii) {
+            if (radius > maxRadius)
+                maxRadius = radius;
+        }
+        maxRadius = std::nextafter(maxRadius, std::numeric_limits<double>::max());
+        root = QuadNodePolarEuclid<T>(0, 0, 2 * PI, maxRadius, capacity, theoreticalSplit, balance);
+        for (index i = 0; i < n; i++) {
+            assert(content[i] < n);
+            root.addContent(content[i], angles[i], radii[i]);
+        }
+    }
+
+    /**
+     * @param newcomer content to be added at point x
+     * @param angle angular coordinate of x
+     * @param R radial coordinate of x
+     */
+    void addContent(T newcomer, double angle, double r) { root.addContent(newcomer, angle, r); }
+
+    /**
+     * @param newcomer content to be removed at point x
+     * @param angle angular coordinate of x
+     * @param R radial coordinate of x
+     */
+    bool removeContent(T toRemove, double angle, double r) {
+        return root.removeContent(toRemove, angle, r);
+    }
+
+    /**
+     * Get all elements, regardless of position
+     *
+     * @return vector<T> of elements
+     */
+    vector<T> getElements() const { return root.getElements(); }
+
+    void extractCoordinates(vector<double> &anglesContainer, vector<double> &radiiContainer) const {
+        root.getCoordinates(anglesContainer, radiiContainer);
+    }
+
+    void getElementsInEuclideanCircle(const Point2DWithIndex<double> circleCenter,
+                                      const double radius, vector<T> &circleDenizens) const {
+        root.getElementsInEuclideanCircle(circleCenter, radius, false, circleDenizens);
+    }
+
+    count getElementsProbabilistically(Point2DWithIndex<double> euQuery,
+                                       std::function<double(double)> prob,
+                                       vector<T> &circleDenizens) {
+        return root.getElementsProbabilistically(euQuery, prob, false, circleDenizens);
+    }
+
+    count getElementsProbabilistically(Point2DWithIndex<double> euQuery,
+                                       std::function<double(double)> prob, bool suppressLeft,
+                                       vector<T> &circleDenizens) {
+        return root.getElementsProbabilistically(euQuery, prob, suppressLeft, circleDenizens);
+    }
+
+    void recount() { root.recount(); }
+
+    count size() const { return root.size(); }
+
+    count height() const { return root.height(); }
+
+    count countLeaves() const { return root.countLeaves(); }
+
+    index indexSubtree(index nextID) { return root.indexSubtree(nextID); }
+
+    index getCellID(double phi, double r) const { return root.getCellID(phi, r); }
+
+    double getMaxRadius() const { return maxRadius; }
+
+    void reindex() {
+#pragma omp parallel
+        {
+#pragma omp single nowait
+            { root.reindex(0); }
+        }
+    }
+
+    /**
+     * trims the vectors used to hold the content in the leaf cells. Reduces memory usage, makes
+     * changes slower
+     */
+    void trim() { root.trim(); }
+
+private:
+    QuadNodePolarEuclid<T> root;
+    double maxRadius;
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_GENERATORS_QUADTREE_QUADTREE_POLAR_EUCLID_HPP_