@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,128 @@
+#ifndef NETWORKIT_GENERATORS_POWERLAW_DEGREE_SEQUENCE_HPP_
+#define NETWORKIT_GENERATORS_POWERLAW_DEGREE_SEQUENCE_HPP_
+
+#include <vector>
+
+#include <networkit/Globals.hpp>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+class PowerlawDegreeSequence final : public Algorithm {
+public:
+    /**
+     * Generates a powerlaw degree sequence with the given minimum and maximum degree, the powerlaw
+     * exponent gamma.
+     *
+     * @param minDeg   The minium degree
+     * @param maxDeg   The maximum degree
+     * @param gamma    The powerlaw exponent
+     */
+    PowerlawDegreeSequence(count minDeg, count maxDeg, double gamma);
+
+    /**
+     * Generates a powerlaw degree sequence that fits the given degree sequence in terms of minimum,
+     * maximum and average degree.
+     *
+     * @param degreeSequence The degree sequence to fit.
+     */
+    PowerlawDegreeSequence(const std::vector<double> &degreeSequence);
+
+    /**
+     * Generates a powerlaw degree sequence that fits the degree sequence of the given graph in
+     * terms of minimum, maximum and average degree.
+     *
+     * @param g The input graph to fit
+     */
+    PowerlawDegreeSequence(const Graph &g);
+
+    /**
+     * Tries to set the minimum degree such that the specified average degree is expected.
+     *
+     * @throws std::runtime_error If it is not possible to find a minimum degree such that the
+     * expected average is @a avgDeg.
+     * @param avgDeg   The average degree
+     */
+    void setMinimumFromAverageDegree(double avgDeg);
+
+    /**
+     * Tries to set the powerlaw exponent gamma such that the specified average degree is expected.
+     *
+     * @param avgDeg The average degree
+     * @param minGamma The minimum gamma to use, default: -1
+     * @param maxGamma The maximum gamma to use, default: -6
+     */
+    void setGammaFromAverageDegree(double avgDeg, double minGamma = -1, double maxGamma = -6);
+
+    /**
+     * Sets the minimum degree.
+     *
+     * @param minDeg The degree that shall be set as minimum degree
+     */
+    void setMinimumDegree(count minDeg);
+
+    /**
+     * Gets the minimum degree.
+     *
+     * @return The minimum degree.
+     */
+    count getMinimumDegree() const;
+
+    /**
+     * Gets the maximum degree.
+     *
+     * @return The maximum degree.
+     */
+    count getMaximumDegree() const { return maxDeg; };
+
+    /**
+     * Sets the exponent gamma.
+     *
+     * @param gamma The exponent, must be negative.
+     */
+    void setGamma(double gamma);
+
+    /**
+     * Gets the exponent gamma.
+     *
+     * @return gamma
+     */
+    double getGamma() const { return gamma; };
+
+    /**
+     * Execute the generation process
+     */
+    void run() override;
+
+    /**
+     * Returns the expected average degree.
+     *
+     * @return The expected average degree.
+     */
+    double getExpectedAverageDegree() const;
+
+    /**
+     * Returns a degree sequence of @a numNodes degrees with even degree sum.
+     *
+     * @param numNodes The number of nodes
+     * @return The generated degree sequence.
+     */
+    std::vector<count> getDegreeSequence(count numNodes) const;
+
+    /**
+     * Returns a degree drawn at random with a power law distribution
+     *
+     * @return A degree that follows the generated distribution.
+     */
+    count getDegree() const;
+
+private:
+    count minDeg, maxDeg;
+    double gamma;
+    std::vector<double> cumulativeProbability;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_GENERATORS_POWERLAW_DEGREE_SEQUENCE_HPP_

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

@@ -0,0 +1,94 @@
+/*
+ * PubWebGenerator.hpp
+ *
+ *  Created on: Apr 10, 2013
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_GENERATORS_PUB_WEB_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_PUB_WEB_GENERATOR_HPP_
+
+#include <vector>
+
+#include <networkit/generators/StaticGraphGenerator.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/viz/Point.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * Generates a static graph that resembles an assumed geometric distribution of nodes in
+ * a P2P network. The basic structure is to distribute points randomly in the unit torus
+ * and to connect vertices close to each other (at most @a neighRad distance and none of
+ * them already has @a maxNeigh neighbors). The distribution is chosen to get some areas with
+ * high density and others with low density. There are @a numDenseAreas dense areas, which can
+ * overlap. Each area is circular, has a certain position and radius and number of points.
+ * These values are strored in @a denseAreaXYR and @a numPerArea, respectively.
+ *
+ * Used and described in more detail in J. Gehweiler, H. Meyerhenke: A Distributed
+ * Diffusive Heuristic for Clustering a Virtual P2P Supercomputer. In Proc. 7th High-Performance
+ * Grid Computing Workshop (HPGC'10), in conjunction with 24th IEEE Internatl. Parallel and
+ * Distributed Processing Symposium (IPDPS'10), IEEE, 2010.
+ *
+ * Reasonable parameters for constructor:
+ * - numNodes: from several hundred up to a few thousand
+ *   (possibly more if visualization is not desired and quadratic time
+ *   complexity has been resolved)
+ * - numberOfDenseAreas: depending on number of nodes, e.g. [8, 50]
+ * - neighborhoodRadius: the higher, the better the connectivity [0.1, 0.35]
+ * - maxNumberOfNeighbors: maximum degree, a higher value corresponds to better connectivity [4, 40]
+ */
+class PubWebGenerator final : public StaticGraphGenerator {
+    friend class DynamicPubWebGenerator;
+
+public:
+    PubWebGenerator() {
+    } // nullary constructor needed for Python Shell - do not use this to construct instance
+    ~PubWebGenerator() override = default;
+
+    PubWebGenerator(count numNodes, count numberOfDenseAreas, coordinate neighborhoodRadius,
+                    count maxNumberOfNeighbors);
+
+    GraphW generate() override;
+
+    const std::vector<Point2D> &getCoordinates() const { return coordinates; }
+    std::vector<Point2D> moveCoordinates() { return std::move(coordinates); }
+
+private:
+    struct circle {
+        coordinate x;
+        coordinate y;
+        coordinate rad;
+    };
+
+    static constexpr coordinate MAX_DENSE_AREA_RADIUS = 0.2;
+    static constexpr coordinate MIN_MAX_DENSE_AREA_FACTOR = 5.0;
+    static constexpr edgeweight BASE_WEIGHT = 0.01;
+
+    count n;                          //!< number of nodes
+    count numDenseAreas;              //!< number of areas with more nodes (denser)
+    coordinate neighRad;              //!< neighborhood radius
+    count maxNeigh;                   //!< maximum number of neighbors
+    std::vector<circle> denseAreaXYR; //!< position of each circular dense area
+    std::vector<count> numPerArea;    //!< number of points in each circular area
+    std::vector<Point2D> coordinates; //!< storage for point coordinates
+
+    Point2D intoUnitSquare(Point2D pt) const noexcept;
+    coordinate squaredDistanceInUnitTorus(Point2D pt1, Point2D pt2) const noexcept;
+
+    void determineNeighbors(GraphW &g);
+    void chooseDenseAreaSizes();
+    void fillDenseAreas(GraphW &g);
+    void spreadRemainingNodes(GraphW &g);
+    void chooseClusterSizes();
+    void addNodesToArea(index area, count num, GraphW &g);
+
+    /**
+     * Adds nodes randomly, distribution respects original one.
+     */
+    void addNode(GraphW &g);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_PUB_WEB_GENERATOR_HPP_

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

@@ -0,0 +1,37 @@
+/*
+ * RegularRingLatticeGenerator.hpp
+ *
+ *  Created on: 09.07.2014
+ *      Author: Simon Bischof
+ */
+
+#ifndef NETWORKIT_GENERATORS_REGULAR_RING_LATTICE_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_REGULAR_RING_LATTICE_GENERATOR_HPP_
+
+#include <networkit/generators/StaticGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class RegularRingLatticeGenerator final : public StaticGraphGenerator {
+
+public:
+    /**
+     * Construct a undirected regular ring lattice.
+     *
+     * @param nNodes     number of nodes in target graph
+     * @param nNeighbors number of neighbors on each side of a node
+     */
+    RegularRingLatticeGenerator(count nNodes, count nNeighbors);
+
+    GraphW generate() override;
+
+private:
+    count nNodes;
+    count nNeighbors;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_REGULAR_RING_LATTICE_GENERATOR_HPP_

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

@@ -0,0 +1,67 @@
+/*
+ * RmatGenerator.hpp
+ *
+ *  Created on: 18.03.2014
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_GENERATORS_RMAT_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_RMAT_GENERATOR_HPP_
+
+#include <stdint.h>
+#include <networkit/generators/StaticGraphGenerator.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * Generates static R-MAT graphs. R-MAT (recursive matrix) graphs are
+ * random graphs with n=2^scale nodes and m=n*edgeFactor edges.
+ * More details at http://www.graph500.org or in the original paper:
+ * Deepayan Chakrabarti, Yiping Zhan, Christos Faloutsos:
+ * R-MAT: A Recursive Model for Graph Mining. SDM 2004: 442-446.
+ */
+class RmatGenerator final : public StaticGraphGenerator {
+    count scale; ///< n = 2^scale
+    count edgeFactor;
+    double defaultEdgeWeight;
+    bool weighted;
+    count reduceNodes;
+    bool discardSelfLoops;
+
+    // Data for the alias table:
+    std::vector<std::pair<uint32_t, uint32_t>> bits;
+    std::vector<uint8_t> numberOfBits;
+    std::vector<uint32_t> coinFlipProbability;
+    std::vector<uint32_t> coinFlipReplacement;
+    uint32_t mask;
+    std::pair<uint32_t, uint32_t> curBits{0, 0};
+    uint32_t remainingBits = 0;
+
+public:
+    /**
+     * @param[in] scale Number of nodes = 2^scale
+     * @param[in] edgeFactor Number of edges = number of nodes * edgeFactor
+     * @param[in] a Probability for quadrant upper left
+     * @param[in] b Probability for quadrant upper right
+     * @param[in] c Probability for quadrant lower left
+     * @param[in] d Probability for quadrant lower right
+     * @param[in] weighted  result graph weighted?
+     * @param[in] reduceNodes  number of random nodes to delete to achieve a given node count
+     * @param[in] discardSelfLoops ignore self loops
+     */
+    RmatGenerator(count scale, count edgeFactor, double a, double b, double c, double d,
+                  bool weighted = false, count reduceNodes = 0, bool discardSelfLoops = true);
+
+    /**
+     * @return Graph to be generated according to parameters specified in constructor.
+     */
+    GraphW generate() override;
+
+private:
+    std::pair<node, node> sampleEdge(uint8_t bits);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_RMAT_GENERATOR_HPP_

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

@@ -0,0 +1,42 @@
+/*
+ * StaticDegreeSequenceGenerator.hpp
+ *
+ *  Created on: 24.02.2014
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_GENERATORS_STATIC_DEGREE_SEQUENCE_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_STATIC_DEGREE_SEQUENCE_GENERATOR_HPP_
+
+#include <networkit/generators/StaticGraphGenerator.hpp>
+
+namespace NetworKit {
+
+// TODO: Clean this up.
+const short NO = 0;
+const short YES = 1;
+const short UNKNOWN = 2;
+
+/**
+ * @ingroup generators
+ */
+class StaticDegreeSequenceGenerator : public StaticGraphGenerator {
+protected:
+    std::vector<count> seq;
+    short realizable;
+
+public:
+    StaticDegreeSequenceGenerator(const std::vector<count> &sequence);
+
+    /**
+     * Erdoes-Gallai test if degree sequence seq is realizable.
+     */
+    virtual bool isRealizable();
+
+    virtual bool getRealizable() const;
+
+    GraphW generate() override = 0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_STATIC_DEGREE_SEQUENCE_GENERATOR_HPP_

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

@@ -0,0 +1,30 @@
+/*
+ * StaticGraphGenerator.hpp
+ *
+ *  Created on: 09.04.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_GENERATORS_STATIC_GRAPH_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_STATIC_GRAPH_GENERATOR_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * Abstract base class for static graph generators.
+ */
+class StaticGraphGenerator {
+
+public:
+    /** Default destructor */
+    virtual ~StaticGraphGenerator() = default;
+
+    virtual GraphW generate() = 0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_STATIC_GRAPH_GENERATOR_HPP_

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

@@ -0,0 +1,41 @@
+/*
+ * StochasticBlockmodel.hpp
+ *
+ *  Created on: 13.08.2014
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_GENERATORS_STOCHASTIC_BLOCKMODEL_HPP_
+#define NETWORKIT_GENERATORS_STOCHASTIC_BLOCKMODEL_HPP_
+
+#include <networkit/generators/StaticGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class StochasticBlockmodel final : public StaticGraphGenerator {
+
+public:
+    /**
+     * Construct a undirected regular ring lattice.
+     *
+     * @param nNodes     number of nodes in target graph
+     * @param n    number of blocks (=k)
+     * @param membership    maps node ids to block ids (consecutive, 0 <= i < nBlocks)
+     * @param affinity    matrix of size k x k with edge probabilities between the blocks
+     */
+    StochasticBlockmodel(count n, count nBlocks, const std::vector<index> &membership,
+                         const std::vector<std::vector<double>> &affinity);
+
+    GraphW generate() override;
+
+private:
+    count n;
+    std::vector<index> membership;
+    const std::vector<std::vector<double>> &affinity;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_STOCHASTIC_BLOCKMODEL_HPP_

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

@@ -0,0 +1,43 @@
+/*
+ * WattsStrogatzGenerator.hpp
+ *
+ *  Created on: 09.07.2014
+ *      Author: Simon Bischof
+ */
+#ifndef NETWORKIT_GENERATORS_WATTS_STROGATZ_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_WATTS_STROGATZ_GENERATOR_HPP_
+
+#include <networkit/generators/StaticGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class WattsStrogatzGenerator final : public StaticGraphGenerator {
+
+public:
+    /**
+     * Constructs a graph according to the Watts and Strogatz model
+     * (https://en.wikipedia.org/wiki/Watts_and_Strogatz_model),
+     * which produces graphs with high clustering and low average path length.
+     *
+     * First, a regular ring lattice is generated.
+     * Then some edges are rewired randomly.
+     *
+     * @param nNodes number of nodes in target graph
+     * @param nNeighbors number of neighbors on each side of a node
+     * @param p rewiring probability
+     */
+    WattsStrogatzGenerator(count nNodes, count nNeighbors, double p);
+
+    GraphW generate() override;
+
+private:
+    count nNodes;
+    count nNeighbors;
+    double p;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_WATTS_STROGATZ_GENERATOR_HPP_