@ladybugmem/icebug 0.1.0 → 0.1.2

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

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

@@ -1,175 +0,0 @@
-#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

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

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