@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/generators/HyperbolicGenerator.hpp

@@ -0,0 +1,236 @@
+/*
+ * HyperbolicGenerator.hpp
+ *
+ *  Created on: 20.05.2014
+ *      Author: Moritz v. Looz
+ */
+
+#ifndef NETWORKIT_GENERATORS_HYPERBOLIC_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_HYPERBOLIC_GENERATOR_HPP_
+
+#include <cmath>
+#include <vector>
+
+#include <networkit/auxiliary/Timer.hpp>
+#include <networkit/generators/StaticGraphGenerator.hpp>
+#include <networkit/generators/quadtree/Quadtree.hpp>
+#include <networkit/geometric/HyperbolicSpace.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class HyperbolicGenerator final : public StaticGraphGenerator {
+    friend class DynamicHyperbolicGenerator;
+
+public:
+    /**
+     * @param[in] n Number of nodes
+     * @param[in] k Target average degree
+     * @param[in] exp Target exponent of power-law distribution
+     * @param[in] T Temperature
+     */
+    HyperbolicGenerator(count n = 10000, double avgDegree = 6, double exp = 3, double T = 0);
+
+    /**
+     * @param[in] angles Pointer to angles of node positions
+     * @param[in] radii Pointer to radii of node positions
+     * @param[in] r radius of poincare disk to place nodes in
+     * @param[in] thresholdDistance Edges are added for nodes closer to each other than this
+     * threshold
+     * @return Graph to be generated according to parameters
+     */
+    GraphW generate(const vector<double> &angles, const vector<double> &radii, double R,
+                    double T = 0);
+
+    GraphW generateCold(const vector<double> &angles, const vector<double> &radii, double R);
+
+    /**
+     * @return Graph to be generated according to parameters specified in constructor.
+     */
+    GraphW generate() override;
+
+    /**
+     * Set the capacity of a quadtree leaf.
+     *
+     * @param capacity Tuning parameter, default value is 1000
+     */
+    void setLeafCapacity(count capacity) { this->capacity = capacity; }
+
+    /**
+     * When using a theoretically optimal split, the quadtree will be flatter, but running time
+     * usually longer.
+     * @param split Whether to use the theoretically optimal split. Defaults to false
+     */
+    void setTheoreticalSplit(bool split) { this->theoreticalSplit = split; }
+
+    void setBalance(double balance) { this->balance = balance; }
+
+    vector<double> getElapsedMilliseconds() const {
+        vector<double> result(threadtimers.size());
+        for (index i = 0; i < result.size(); i++) {
+            result[i] = threadtimers[i].elapsedMilliseconds();
+        }
+        return result;
+    }
+
+private:
+    /**
+     * Set tuning parameters to their default values
+     */
+    void initialize();
+
+    GraphW generate(count n, double R, double alpha, double T = 0);
+
+    static vector<vector<double>>
+    getBandAngles(const vector<vector<Point2DWithIndex<double>>> &bands) {
+        vector<vector<double>> bandAngles(bands.size());
+#pragma omp parallel for
+        for (omp_index i = 0; i < static_cast<omp_index>(bands.size()); i++) {
+            const count currentBandSize = bands[i].size();
+            bandAngles[i].resize(currentBandSize);
+            for (index j = 0; j < currentBandSize; j++) {
+                bandAngles[i][j] = bands[i][j].getX();
+            }
+        }
+        return bandAngles;
+    }
+
+    static vector<double> getBandRadii(int n, double R, double seriesRatio = 0.9) {
+        /*
+         * We assume band differences form a geometric series.
+         * Thus, there is a constant ratio(r) between band length differences
+         * i.e (c2-c1)/(c1-c0) = (c3-c2)/(c2-c1) = r
+         */
+        vector<double> bandRadius;
+        bandRadius.push_back(0);
+        double a = R * (1 - seriesRatio) / (1 - std::pow(seriesRatio, std::log(n)));
+        const double logn = std::log(n);
+
+        for (int i = 1; i < logn; i++) {
+            double c_i = a * ((1 - std::pow(seriesRatio, i)) / (1 - seriesRatio));
+            bandRadius.push_back(c_i);
+        }
+        bandRadius.push_back(R);
+        return bandRadius;
+    }
+
+    static std::tuple<double, double> getMinMaxTheta(double angle, double radius, double cLow,
+                                                     double thresholdDistance) {
+        /**
+        Calculates the angles that are enclosing the intersection of the hyperbolic disk that is
+        around point v and the bands. Calculation is as follows:
+         1. For the most inner band, return [0, 2pi]
+         2. For other bands, consider the point P which lies on the tangent from origin to the
+         disk of point v. Its radial coordinates would be(cHigh, point[1]+deltaTheta). We're
+         looking for the deltaTheta. We know the distance from point v to P is R. Thus, we can
+         solve the hyperbolic distance of (v, P) for deltaTheta. Then, thetaMax is simply
+         point[1] + deltaTheta and thetaMin is point[1] - deltaTheta.
+        */
+
+        // Most innerband is defined by cLow = 0
+        double minTheta, maxTheta;
+        if (cLow == 0)
+            return std::make_tuple(0.0, 2 * PI);
+
+        double a = (std::cosh(radius) * std::cosh(cLow) - std::cosh(thresholdDistance))
+                   / (std::sinh(radius) * std::sinh(cLow));
+        // handle floating point error
+        if (a < -1)
+            a = -1;
+        else if (a > 1)
+            a = 1;
+        a = std::acos(a);
+        maxTheta = angle + a;
+        minTheta = angle - a;
+        return std::make_tuple(minTheta, maxTheta);
+    }
+
+    static vector<Point2DWithIndex<double>>
+    getPointsWithinAngles(double minTheta, double maxTheta,
+                          const vector<Point2DWithIndex<double>> &band,
+                          vector<double> &bandAngles) {
+        /**
+        Returns the list of points, w, that lies within minTheta and maxTheta
+        in the supplied band(That area is called as slab)
+        */
+        assert(band.size() == bandAngles.size());
+
+        vector<Point2DWithIndex<double>> slab;
+
+        std::vector<double>::iterator low;
+        std::vector<double>::iterator high;
+
+        if (minTheta == -2 * PI)
+            minTheta = 0;
+        // Case 1: We do not have overlap 2pi, simply put all the points between min and max to the
+        // list
+        if (maxTheta <= 2 * PI && minTheta >= 0) {
+            low = std::lower_bound(bandAngles.begin(), bandAngles.end(), minTheta);
+            high = std::upper_bound(bandAngles.begin(), bandAngles.end(), maxTheta);
+            auto first = band.begin() + (low - bandAngles.begin());
+            auto last = band.begin() + (high - bandAngles.begin());
+            // Q: Does this operation increases the complexity ? It is linear in times of high - low
+            // Does not increase the complexity, since we have to check these points anyway
+            slab.insert(slab.end(), first, last);
+        }
+        // Case 2: We have 'forward' overlap at 2pi, that is maxTheta > 2pi
+        else if (maxTheta > 2 * PI) {
+            // 1. Get points from minTheta to 2pi
+            low = std::lower_bound(bandAngles.begin(), bandAngles.end(), minTheta);
+            high = std::upper_bound(bandAngles.begin(), bandAngles.end(), 2 * PI);
+            auto first = band.begin() + (low - bandAngles.begin());
+            auto last = band.begin() + (high - bandAngles.begin());
+            slab.insert(slab.end(), first, last);
+
+            // 2. Get points from 0 to maxTheta%2pi
+            low = std::lower_bound(bandAngles.begin(), bandAngles.end(), 0);
+            maxTheta = fmod(maxTheta, (2 * PI));
+            high = std::upper_bound(bandAngles.begin(), bandAngles.end(), maxTheta);
+            auto first2 = band.begin() + (low - bandAngles.begin());
+            auto last2 = band.begin() + (high - bandAngles.begin());
+            slab.insert(slab.end(), first2, last2);
+        }
+        // Case 3: We have 'backward' overlap at 2pi, that is minTheta < 0
+        else if (minTheta < 0) {
+            // 1. Get points from 2pi + minTheta to 2pi
+            minTheta = (2 * PI) + minTheta;
+            low = std::lower_bound(bandAngles.begin(), bandAngles.end(), minTheta);
+            high = std::upper_bound(bandAngles.begin(), bandAngles.end(), 2 * PI);
+            auto first = band.begin() + (low - bandAngles.begin());
+            auto last = band.begin() + (high - bandAngles.begin());
+            slab.insert(slab.end(), first, last);
+
+            // 2. Get points from 0 to maxTheta
+            low = std::lower_bound(bandAngles.begin(), bandAngles.end(), 0);
+            high = std::upper_bound(bandAngles.begin(), bandAngles.end(), maxTheta);
+            auto first2 = band.begin() + (low - bandAngles.begin());
+            auto last2 = band.begin() + (high - bandAngles.begin());
+            slab.insert(slab.end(), first2, last2);
+        }
+        return slab;
+    }
+
+    /**
+     * graph parameters
+     */
+    count nodeCount;
+    double R;
+    double alpha;
+    double temperature;
+
+    /**
+     * tuning parameters
+     */
+    count capacity;
+    bool theoreticalSplit;
+    double balance = 0.5;
+
+    /**
+     * times
+     */
+    vector<Aux::Timer> threadtimers;
+};
+} // namespace NetworKit
+#endif // NETWORKIT_GENERATORS_HYPERBOLIC_GENERATOR_HPP_

package/vendor/include/networkit/generators/LFRGenerator.hpp

@@ -0,0 +1,175 @@
+#ifndef NETWORKIT_GENERATORS_LFR_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_LFR_GENERATOR_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/generators/StaticGraphGenerator.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * The LFR clustered graph generator as introduced by Andrea Lancichinetti, Santo Fortunato, and
+ * Filippo Radicchi.
+ *
+ * The community assignment follows the algorithm described in
+ * "Benchmark graphs for testing community detection algorithms". The edge generation is however
+ * taken from their follow-up publication "Benchmarks for testing community detection algorithms on
+ * directed and weighted graphs with overlapping communities". Parts of the implementation follow
+ * the choices made in their implementation which is available at
+ * https://sites.google.com/site/andrealancichinetti/software but other parts differ, for example
+ * some more checks for the realizability of the community and degree size distributions are done
+ * instead of heavily modifying the distributions.
+ *
+ * The edge-switching markov-chain algorithm implementation in NetworKit is used which is different
+ * from the implementation in the original LFR benchmark.
+ */
+class LFRGenerator final : public Algorithm, public StaticGraphGenerator {
+public:
+    /**
+     * Initialize the LFR generator for @a n nodes.
+     *
+     * @note You need to set a degree sequence, a community size sequence and a mu using the
+     * additionally provided set- or generate-methods.
+     *
+     * @param n The number of nodes.
+     */
+    LFRGenerator(count n);
+
+    /**
+     * Set the given degree sequence.
+     *
+     * @param degreeSequence The degree sequence that shall be used by the generator
+     */
+    void setDegreeSequence(std::vector<count> degreeSequence);
+
+    /**
+     * Generate and set a power law degree sequence using the given average and maximum degree with
+     * the given exponent.
+     *
+     * @param avgDegree The average degree that shall be reached.
+     * @param maxDegree The maximum degree that shall be generated.
+     * @param nodeDegreeExp The (negative) exponent of the powerlaw degree sequence.
+     */
+    void generatePowerlawDegreeSequence(count avgDegree, count maxDegree, double nodeDegreeExp);
+
+    /**
+     * Set the given community size sequence.
+     *
+     * @param communitySizeSequence The community sizes that shall be used.
+     */
+    void setCommunitySizeSequence(std::vector<count> communitySizeSequence);
+
+    /**
+     * Set the partition, this replaces the community size sequence and the random assignment of the
+     * nodes to communities.
+     *
+     * @param zeta The partition to use
+     */
+    void setPartition(Partition zeta);
+
+    /**
+     * Generate a powerlaw community size sequence with the given minimum and maximum size and the
+     * given exponent.
+     *
+     * @param minCommunitySize The minimum community size to generate
+     * @param maxCommunitySize The maximum community size to generate
+     * @param communitySizeExp The (negative) exponent of the power law community size sequence
+     */
+    void generatePowerlawCommunitySizeSequence(count minCommunitySize, count maxCommunitySize,
+                                               double communitySizeExp);
+
+    /**
+     * Set the mixing parameter, this is the fraction of neighbors of each node that do not belong
+     * to the node's own community.
+     *
+     * @param mu The mixing parameter that shall be set.
+     */
+    void setMu(double mu);
+
+    /**
+     * Set the mixing parameter separately for each node. This is for each node the fraction of
+     * neighbors that do not belong to the node's own community.
+     *
+     * @param mu The mixing parameter for each node.
+     */
+    void setMu(const std::vector<double> &mu);
+
+    /**
+     * Set the internal degree of each node using a binomial distribution such that the expected
+     * mixing parameter is the given @a mu.
+     *
+     * The mixing parameter is for each node the fraction of neighbors that do not belong to the
+     * node's own community.
+     *
+     * @param mu The expected mu that shall be used.
+     */
+    void setMuWithBinomialDistribution(double mu);
+
+    /**
+     * Generates the graph and the community structure. The algorithm is not parallel.
+     */
+    void run() override;
+
+    /**
+     * Generates and returns the graph.
+     *
+     * @return The generated graph.
+     */
+    GraphW generate() override;
+
+    /**
+     * Returns (a copy of) the generated graph.
+     *
+     * @return The generated graph.
+     */
+    GraphW getGraph() const;
+
+    /**
+     * Returns the generated graph using move semantics.
+     *
+     * @return The generated graph.
+     */
+    GraphW &&getMoveGraph();
+
+    /**
+     * Returns (a copy of) the generated partition
+     *
+     * @return The generated graph.
+     */
+    Partition getPartition() const;
+
+    /**
+     * Returns the generated partition using move semantics.
+     *
+     * @return The generated partition.
+     */
+    Partition &&getMovePartition();
+
+private:
+    /*
+     * These methods might be overridden by a sub-class which could use a different model or
+     * generator in order to generate the parts of the graph.
+     */
+    std::vector<std::vector<node>> assignNodesToCommunities();
+    GraphW generateIntraClusterGraph(std::vector<count> intraDegreeSequence,
+                                     const std::vector<node> &localToGlobalNode);
+    GraphW generateInterClusterGraph(const std::vector<count> &externalDegreeSequence);
+
+    count n;
+    bool hasDegreeSequence;
+    std::vector<count> degreeSequence;
+    bool hasCommunitySizeSequence;
+    std::vector<count> communitySizeSequence;
+    bool hasInternalDegreeSequence;
+    std::vector<count> internalDegreeSequence;
+    bool hasGraph;
+    GraphW G;
+    bool hasPartition;
+    Partition zeta;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_GENERATORS_LFR_GENERATOR_HPP_

package/vendor/include/networkit/generators/MocnikGenerator.hpp

@@ -0,0 +1,147 @@
+/*
+ * MocnikGenerator.hpp
+ *
+ * Created on: July 7, 2018
+ * Author: Franz-Benjamin Mocnik <mail@mocnik-science.net>
+ */
+
+#ifndef NETWORKIT_GENERATORS_MOCNIK_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_MOCNIK_GENERATOR_HPP_
+
+#include <networkit/generators/StaticGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class MocnikGenerator final : public StaticGraphGenerator {
+    // GENERAL DATA
+
+    /**
+     * Position of each node in space.  The index of the vector is also the number of
+     * the node.
+     */
+    std::vector<std::vector<double>> nodePositions;
+
+    // DATA FOR EACH LAYER
+
+    /**
+     * Collection of nodes.
+     */
+    using NodeCollection = std::vector<node>;
+
+    /**
+     * The cell array reflects how nodes are assigned to a grid. Each element of
+     * the vector corresponds to one grid cell.
+     */
+    using CellArray = std::vector<NodeCollection>;
+
+    /**
+     * State of a layer
+     */
+    struct LayerState {
+        CellArray a;
+        int aMax;
+    };
+
+    // FUNCTIONS RELATED TO THE LAYER STATE
+
+    /**
+     * Initialize the cell array.  The second parameter determines how many grid
+     * cells shall be contained in each dimension of the cell array.
+     */
+    void initCellArray(LayerState &s, count numberOfCellsPerDimension);
+
+    /**
+     * Get all nodes that are contained in the i-th grid cell
+     */
+    NodeCollection getNodes(LayerState &s, int i);
+
+    /**
+     * Add the node with number j to the corresponing grid cell
+     */
+    void addNode(LayerState &s, int j);
+
+    /**
+     * Determine, for a given position, the index of the corresponding grid cell
+     */
+    int toIndex(LayerState &s, const std::vector<double> &v);
+
+    /**
+     * Determine, for the given multi-dimensional index, the index of the
+     * corresponding grid cell
+     */
+    int toIndex(LayerState &s, const std::vector<int> &v);
+
+    /**
+     * Determine, for a given index, the multi-dimensional index of a grid cell
+     */
+    std::vector<int> fromIndex(LayerState &s, int i);
+
+    /**
+     * Determine for a grid cell given by index i the grid cells of distance r
+     */
+    std::vector<int> boxSurface(LayerState &s, int i, int r);
+
+    /**
+     * Determine for a grid cell given by index i the grid cells within distance r
+     */
+    std::vector<int> boxVolume(LayerState &s, int j, double r);
+
+    // EDGE GENERATION
+
+    /**
+     * Add the edges for n nodes and with parameter k to the graph.  Thereby, use the
+     * provided relative weight.  If it is indicated that the edge is part of the
+     * base layer, it is not tested whether the edge already exists inside the graph.
+     */
+    void addEdgesToGraph(GraphW &G, count n, double k, double relativeWeight, bool baseLayer);
+
+    count dim;
+    std::vector<count> ns;
+    std::vector<double> ks;
+    bool weighted;
+    std::vector<double> relativeWeights;
+
+public:
+    /**
+     * Creates random spatial graphs according to the Mocnik model.
+     *
+     * Please cite the following publications, in which you will find a
+     * description of the model:
+     *
+     * Franz-Benjamin Mocnik: "The Polynomial Volume Law of Complex Networks in
+     * the Context of Local and Global Optimization", Scientific Reports 8(11274)
+     * 2018. doi: 10.1038/s41598-018-29131-0
+     *
+     * Franz-Benjamin Mocnik, Andrew Frank: "Modelling Spatial Structures",
+     * Proceedings of the 12th Conference on Spatial Information Theory (COSIT),
+     * 2015, pages 44-64. doi: 10.1007/978-3-319-23374-1_3
+     *
+     * Improved algorithm.
+     *
+     * @param dim  Dimension of the space.
+     * @param n  Number of nodes in the graph; or a list containing the numbers
+     *     of nodes in each layer in case of a hierarchical model.
+     * @param k  Density parameter, determining the ratio of edges to nodes; in
+     *     case of a hierarchical model, also a list of density parameters can be
+     *     provided.
+     * @param weighted  Determines whether weights should be added to the edges;
+     *     in case of a hierarchical model, also a list of relative weights can be
+     *     provided.
+     */
+    MocnikGenerator(count dim, count n, double k, bool weighted = false);
+    MocnikGenerator(count dim, std::vector<count> ns, double k, bool weighted = false);
+    MocnikGenerator(count dim, std::vector<count> ns, std::vector<double> ks,
+                    bool weighted = false);
+    MocnikGenerator(count dim, count n, double k, std::vector<double> weighted);
+    MocnikGenerator(count dim, std::vector<count> ns, double k, std::vector<double> weighted);
+    MocnikGenerator(count dim, std::vector<count> ns, std::vector<double> ks,
+                    std::vector<double> weighted);
+
+    GraphW generate() override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_MOCNIK_GENERATOR_HPP_

package/vendor/include/networkit/generators/MocnikGeneratorBasic.hpp

@@ -0,0 +1,58 @@
+/*
+ * MocnikGeneratorBasic.hpp
+ *
+ * Created on: July 7, 2018
+ * Author: Franz-Benjamin Mocnik <mail@mocnik-science.net>
+ */
+
+#ifndef NETWORKIT_GENERATORS_MOCNIK_GENERATOR_BASIC_HPP_
+#define NETWORKIT_GENERATORS_MOCNIK_GENERATOR_BASIC_HPP_
+
+#include <networkit/generators/StaticGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class MocnikGeneratorBasic : public StaticGraphGenerator {
+    // GENERAL DATA
+
+    /**
+     * Position of each node in space.  The index of the vector is also the number of
+     * the node.
+     */
+    std::vector<std::vector<double>> nodePositions;
+
+    count dim;
+    count n;
+    double k;
+
+public:
+    /**
+     * Creates random spatial graphs according to the Mocnik model.
+     *
+     * Please cite the following publications, in which you will find a
+     * description of the model:
+     *
+     * Franz-Benjamin Mocnik: "The Polynomial Volume Law of Complex Networks in
+     * the Context of Local and Global Optimization", Scientific Reports 8(11274)
+     * 2018. doi: 10.1038/s41598-018-29131-0
+     *
+     * Franz-Benjamin Mocnik, Andrew Frank: "Modelling Spatial Structures",
+     * Proceedings of the 12th Conference on Spatial Information Theory (COSIT),
+     * 2015, pages 44-64. doi: 10.1007/978-3-319-23374-1_3
+     *
+     * Non-improved algorithm.
+     *
+     * @param dim  Dimension of the space.
+     * @param n  Number of nodes in the graph.
+     * @param k  Density parameter, determining the ratio of edges to nodes.
+     */
+    MocnikGeneratorBasic(count dim, count n, double k);
+
+    GraphW generate() override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_MOCNIK_GENERATOR_BASIC_HPP_