@ladybugmem/icebug 0.1.0 → 0.1.2

package/vendor/include/networkit/geometric/HyperbolicSpace.hpp

@@ -1,248 +0,0 @@
-/*
- * HyperbolicSpace.hpp
- *
- *  Created on: 20.05.2014
- *      Author: Moritz v. Looz
- */
-
-#ifndef NETWORKIT_GEOMETRIC_HYPERBOLIC_SPACE_HPP_
-#define NETWORKIT_GEOMETRIC_HYPERBOLIC_SPACE_HPP_
-
-#include <cmath>
-#include <map>
-#include <vector>
-
-#include <networkit/auxiliary/Random.hpp>
-#include <networkit/geometric/Point2DWithIndex.hpp>
-#include <networkit/viz/Point.hpp>
-
-using std::abs;
-using std::vector;
-
-namespace NetworKit {
-
-class HyperbolicSpace final {
-public:
-    HyperbolicSpace() = default;
-    ~HyperbolicSpace() = default;
-    /**
-     * @param angles empty vector to hold angular coordinates of generated points
-     * @param radii empty vector to hold radial coordinates of generated points
-     * @param R radius of the hyperbolic disk
-     * @param alpha dispersion parameter for the node positions
-     *
-     * Fill preallocated vectors with randomly sampled points in native coordinates
-     */
-    static void fillPoints(vector<double> &angles, vector<double> &radii, double R, double alpha);
-
-    /**
-     * @param angles empty vector to hold angular coordinates of generated points
-     * @param radii empty vector to hold radial coordinates of generated points
-     * @param stretch multiplier for the radius of the hyperbolic disk
-     * @param alpha dispersion parameter for the node positions
-     *
-     * Fill preallocated vectors with randomly sampled points in native coordinates
-     */
-    static void fillPoints(vector<double> &angles, vector<double> &radii, double minPhi,
-                           double maxPhi, double minR, double maxR, double alpha);
-
-    /**
-     * @param angles empty vector to hold angular coordinates of generated points
-     * @param radii empty vector to hold radial coordinates of generated points
-     * @param R radius of the hyperbolic disk
-     * @param alpha dispersion parameter for the node positions
-     *
-     * Fill preallocated vectors with randomly sampled points in native coordinates
-     * The points are sorted by angle
-     */
-    static void fillPointsSorted(vector<double> &angles, vector<double> &radii, double R,
-                                 double alpha);
-
-    /**
-     * @param angles empty vector to hold angular coordinates of generated points
-     * @param radii empty vector to hold radial coordinates of generated points
-     * @param stretch multiplier for the radius of the hyperbolic disk
-     * @param alpha dispersion parameter for the node positions
-     *
-     * Fill preallocated vectors with randomly sampled points in native coordinates
-     * The points are sorted by angle
-     */
-    static void fillPointsSorted(vector<double> &angles, vector<double> &radii, double minPhi,
-                                 double maxPhi, double minR, double maxR, double alpha);
-
-    /**
-     * @param firstangle angular coordinate of the first point
-     * @param firstR radial coordinate of the first point
-     * @param secondangle angular coordinate of the second point
-     * @param secondR radial coordinate of the second point
-     *
-     * @return distance between two points in the poincare metric
-     */
-    static double poincareMetric(double firstangle, double firstR, double secondangle,
-                                 double secondR);
-
-    /**
-     * @param firstangle angular coordinate of the first point
-     * @param firstR radial coordinate of the first point
-     * @param secondangle angular coordinate of the second point
-     * @param secondR radial coordinate of the second point
-     *
-     * @return distance between two points in native hyperbolic representation
-     */
-    static double nativeDistance(double firstangle, double firstR, double secondangle,
-                                 double secondR);
-
-    /**
-     * @param a first point in cartesian coordinates
-     * @param b second point in cartesian coordinates
-     *
-     * @return distance between a and b in the poincare metric
-     */
-    static double poincareMetric(Point2DWithIndex<double> a, Point2DWithIndex<double> b);
-
-    /**
-     * @param phi angular coordinate of point
-     * @param r radial coordinate of point
-     *
-     * @return cartesian coordinates represented by phi and r
-     */
-    static Point2DWithIndex<double> polarToCartesian(double phi, double r);
-
-    /**
-     * Convenience function for visualizations which expect coordinates as map<index,Point<float> >
-     */
-    static std::map<index, Point<float>> polarToCartesian(const vector<double> &angles,
-                                                          const vector<double> &radii);
-
-    /**
-     * @param a cartesian coordinates
-     * @param phi empty double value to receive angular coordinate
-     * @param r empty double value to receive radial coordinate
-     */
-    static void cartesianToPolar(Point2DWithIndex<double> a, double &phi, double &r);
-
-    /**
-     * Converts a hyperbolic circle to a Euclidean circle
-     *
-     * @param hyperbolicCenter center of the hyperbolic circle, given in cartesian coordinates
-     * within the poincare disk
-     * @param hyperbolicRadius radius of the hyperbolic circle
-     * @param euclideanCenter point to receive the center of the Euclidean circle, given in
-     * cartesian coordinates
-     * @param euclidenRadius double to receive the radius of the Euclidean circle
-     */
-    static void getEuclideanCircle(Point2DWithIndex<double> hyperbolicCenter,
-                                   double hyperbolicRadius,
-                                   Point2DWithIndex<double> &euclideanCenter,
-                                   double &euclideanRadius);
-    static void getEuclideanCircle(double r_h, double hyperbolicRadius,
-                                   double &radialCoordOfEuclideanCenter, double &euclideanRadius);
-
-    /**
-     * Project radial coordinates of the hyperbolic plane into the Poincare disk model
-     *
-     * @param hyperbolicRadius radial coordinate of a point in the native hyperbolic disc
-     * @return radial coordinate in the Poincare model
-     */
-    static double hyperbolicRadiusToEuclidean(double hyperbolicRadius);
-
-    /**
-     * Project radial coordinates of the Poincare model into the hyperbolic plane
-     *
-     * @param EuclideanRadius Radial coordinate of a point in the Poincare model
-     * @return radial coordinate in the hyperbolic plane
-     */
-    static double EuclideanRadiusToHyperbolic(double EuclideanRadius);
-
-    /**
-     * @param area The area of the hyperbolic circle
-     * @param return Radius of a hyperbolic circle with the given area
-     */
-    static inline double hyperbolicAreaToRadius(double area) {
-        return std::acosh(area / (2 * PI) + 1);
-    }
-
-    static inline double radiusToHyperbolicArea(double radius) {
-        return 2 * PI * (std::cosh(radius) - 1);
-    }
-
-    static double getExpectedDegree(double n, double alpha, double R) {
-        double gamma = 2 * alpha + 1;
-        double xi = (gamma - 1) / (gamma - 2);
-        double firstSumTerm = std::exp(-R / 2);
-        double secondSumTerm =
-            std::exp(-alpha * R)
-            * (alpha * (R / 2)
-                   * ((PI / 4) * std::pow((1 / alpha), 2) - (PI - 1) * (1 / alpha) + (PI - 2))
-               - 1);
-        double expectedDegree = (2 / PI) * xi * xi * n * (firstSumTerm + secondSumTerm);
-        return expectedDegree;
-    }
-
-    static double searchTargetRadiusForColdGraphs(double n, double k, double alpha,
-                                                  double epsilon) {
-        double gamma = 2 * alpha + 1;
-        double xiInv = ((gamma - 2) / (gamma - 1));
-        double v = k * (PI / 2) * xiInv * xiInv;
-        double currentR = 2 * std::log(n / v);
-        double lowerBound = currentR / 2;
-        double upperBound = currentR * 2;
-        assert(getExpectedDegree(n, alpha, lowerBound) > k);
-        assert(getExpectedDegree(n, alpha, upperBound) < k);
-        do {
-            currentR = (lowerBound + upperBound) / 2;
-            double currentK = getExpectedDegree(n, alpha, currentR);
-            if (currentK < k) {
-                upperBound = currentR;
-            } else {
-                lowerBound = currentR;
-            }
-        } while (abs(getExpectedDegree(n, alpha, currentR) - k) > epsilon);
-        return currentR;
-    }
-
-    static double getTargetRadius(double n, double m, double alpha = 1, double T = 0,
-                                  double epsilon = 0.01) {
-        double result;
-        double plexp = 2 * alpha + 1;
-        double targetAvgDegree = (m / n) * 2;
-        double xiInv = ((plexp - 2) / (plexp - 1));
-        if (T == 0) {
-            result = searchTargetRadiusForColdGraphs(n, targetAvgDegree, alpha, epsilon);
-        } else {
-            double beta = 1 / T;
-            if (T < 1) { // cold regime
-                double Iinv = ((beta / PI) * std::sin(PI / beta));
-                double v = (targetAvgDegree * Iinv) * (PI / 2) * xiInv * xiInv;
-                result = 2 * std::log(n / v);
-            } else { // hot regime
-                double v = targetAvgDegree * (1 - beta) * std::pow((PI / 2), beta) * xiInv * xiInv;
-                result = 2 * std::log(n / v) / beta;
-            }
-        }
-        return result;
-    }
-
-    static inline double effectiveAreaInCell(double minPhi, double maxPhi, double minR, double maxR,
-                                             double alpha) {
-        double deltaPhi = maxPhi - minPhi;
-        assert(deltaPhi >= 0);
-        assert(deltaPhi <= 2 * PI);
-        double ringArea = radiusToHyperbolicArea(alpha * EuclideanRadiusToHyperbolic(maxR))
-                          - radiusToHyperbolicArea(alpha * EuclideanRadiusToHyperbolic(minR));
-        return ringArea * (deltaPhi / (2 * PI));
-    }
-
-    /**
-     * @param r_c radial coordinate of the circle center
-     * @param d_c radius of the Euclidean circle
-     * @param R radius of the hyperbolic base disk
-     */
-    static double hyperbolicSpaceInEuclideanCircle(double r_c, double d_c, double R);
-
-    static double maxRinSlice(double minPhi, double maxPhi, double phi_c, double r_c,
-                              double euRadius);
-};
-} // namespace NetworKit
-
-#endif // NETWORKIT_GEOMETRIC_HYPERBOLIC_SPACE_HPP_

package/vendor/include/networkit/geometric/Point2DWithIndex.hpp

@@ -1,145 +0,0 @@
-/*
- * Point2DWithIndex.hpp
- *
- *  Created on: 24.07.2014
- *      Author: moritzl
- */
-
-#ifndef NETWORKIT_GEOMETRIC_POINT2_D_WITH_INDEX_HPP_
-#define NETWORKIT_GEOMETRIC_POINT2_D_WITH_INDEX_HPP_
-
-#include <cassert>
-#include <cinttypes>
-#include <cmath>
-#include <cstdint>
-#include <vector>
-
-#include <networkit/Globals.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup viz
- * Points in any dimension of templated type.
- */
-template <class T>
-class Point2DWithIndex final {
-private:
-    T x;
-    T y;
-    index indice;
-
-public:
-    Point2DWithIndex() {
-        x = 0;
-        y = 0;
-        indice = 0;
-    }
-    Point2DWithIndex(T x, T y) {
-        this->x = x;
-        this->y = y;
-        this->indice = 0;
-    }
-    Point2DWithIndex(T x, T y, index indice) {
-        this->x = x;
-        this->y = y;
-        this->indice = indice;
-    }
-
-    count getDimensions() { return 2; }
-
-    T distance(const Point2DWithIndex<T> &p) const;
-    T squaredDistance(const Point2DWithIndex<T> &p) const;
-
-    Point2DWithIndex &operator+=(const Point2DWithIndex<T> &p);
-    Point2DWithIndex &operator-=(const Point2DWithIndex<T> &p);
-    Point2DWithIndex &scale(T factor);
-
-    Point2DWithIndex operator-(const Point2DWithIndex<T> &other);
-    Point2DWithIndex operator+(const Point2DWithIndex<T> &other);
-
-    T length() const;
-    T squaredLength() const;
-
-    T &operator[](index i);
-    T getX() const;
-    T getY() const;
-    index getIndex() const;
-};
-
-template <class T>
-T Point2DWithIndex<T>::length() const {
-    return std::sqrt(x * x + y * y);
-}
-
-template <class T>
-T Point2DWithIndex<T>::squaredLength() const {
-    return x * x + y * y;
-}
-
-template <class T>
-T Point2DWithIndex<T>::squaredDistance(const Point2DWithIndex<T> &p) const {
-    T diffx = p.x - x;
-    T diffy = p.y - y;
-    return diffx * diffx + diffy * diffy;
-}
-
-template <class T>
-T Point2DWithIndex<T>::distance(const Point2DWithIndex<T> &p) const {
-    return std::sqrt(squaredDistance(p));
-}
-
-template <class T>
-Point2DWithIndex<T> &Point2DWithIndex<T>::operator+=(const Point2DWithIndex<T> &p) {
-    this->x += p.x;
-    this->y += p.y;
-    return *this;
-}
-
-template <class T>
-Point2DWithIndex<T> &Point2DWithIndex<T>::operator-=(const Point2DWithIndex<T> &p) {
-    this->x -= p.x;
-    this->y -= p.y;
-    return *this;
-}
-
-template <class T>
-Point2DWithIndex<T> Point2DWithIndex<T>::operator-(const Point2DWithIndex<T> &other) {
-    return Point2DWithIndex(x - other.x, y - other.y);
-}
-
-template <class T>
-Point2DWithIndex<T> Point2DWithIndex<T>::operator+(const Point2DWithIndex<T> &other) {
-    return Point2DWithIndex(x + other.x, y + other.y);
-}
-
-template <class T>
-Point2DWithIndex<T> &Point2DWithIndex<T>::scale(T factor) {
-    x *= factor;
-    y *= factor;
-    return *this;
-}
-
-template <class T>
-inline T &Point2DWithIndex<T>::operator[](index i) {
-    assert(i < 2);
-    return i > 0 ? y : x;
-}
-
-template <class T>
-inline T Point2DWithIndex<T>::getX() const {
-    return x;
-}
-
-template <class T>
-inline T Point2DWithIndex<T>::getY() const {
-    return y;
-}
-
-template <class T>
-inline index Point2DWithIndex<T>::getIndex() const {
-    return indice;
-}
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_GEOMETRIC_POINT2_D_WITH_INDEX_HPP_

package/vendor/include/networkit/global/ClusteringCoefficient.hpp

@@ -1,42 +0,0 @@
-/*
- * ClusteringCoefficient.hpp
- *
- *  Created on: 08.04.2013
- *      Author: Lukas Barth, David Weiss
- */
-
-#ifndef NETWORKIT_GLOBAL_CLUSTERING_COEFFICIENT_HPP_
-#define NETWORKIT_GLOBAL_CLUSTERING_COEFFICIENT_HPP_
-
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup global
- */
-class ClusteringCoefficient final {
-
-public:
-    /**
-     * DEPRECATED: use centrality.LocalClusteringCoefficient and take average
-     *
-     * This calculates the average local clustering coefficient of graph @a G.
-     *
-     * @param G The graph (may not contain self-loops).
-     * @note $$c(G) := \\frac{1}{n} \\sum_{u \\in V} c(u)$$
-     * where $c(u) := \\frac{2 \\cdot |E(N(u))| }{\\deg(u) \\cdot ( \\deg(u) - 1)}$
-     */
-    static double avgLocal(Graph &G, bool turbo = false);
-    static double sequentialAvgLocal(const Graph &G);
-    static double approxAvgLocal(Graph &G, count trials);
-
-    /**
-     * This calculates the global clustering coefficient
-     */
-    static double exactGlobal(Graph &G);
-    static double approxGlobal(Graph &G, count trials);
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_GLOBAL_CLUSTERING_COEFFICIENT_HPP_

package/vendor/include/networkit/global/GlobalClusteringCoefficient.hpp

@@ -1,24 +0,0 @@
-/*
- * GlobalClusteringCoefficient.hpp
- *
- *  Created on: 12.11.2013
- */
-
-#ifndef NETWORKIT_GLOBAL_GLOBAL_CLUSTERING_COEFFICIENT_HPP_
-#define NETWORKIT_GLOBAL_GLOBAL_CLUSTERING_COEFFICIENT_HPP_
-
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup global
- */
-class GlobalClusteringCoefficient {
-
-public:
-    virtual double approximate(const Graph &G, int k);
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_GLOBAL_GLOBAL_CLUSTERING_COEFFICIENT_HPP_