@ladybugmem/icebug 0.1.0 → 0.1.2

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

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

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

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

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

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

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

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

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