@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,56 @@
+/*
+ * ClusteredRandomGraphGenerator.hpp
+ *
+ *  Created on: 28.02.2014
+ *      Author: cls
+ *              Eugenio Angriman <angrimae@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_GENERATORS_CLUSTERED_RANDOM_GRAPH_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_CLUSTERED_RANDOM_GRAPH_GENERATOR_HPP_
+
+#include <networkit/generators/StaticGraphGenerator.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * The ClusteredRandomGraphGenerator class is used to create a clustered random graph.
+ * The number of nodes and the number of edges are adjustable as well as the probabilities
+ * for intra-cluster and inter-cluster edges.
+ * In parallel the generated graph is not deterministic. To ensure determinism, use a single thread.
+ */
+class ClusteredRandomGraphGenerator final : public StaticGraphGenerator {
+public:
+    /**
+     * Creates a clustered random graph:
+     *
+     * @param[in]	n	number of nodes
+     * @param[in]	k	number of clusters
+     * @param[in]	pIntra		intra-cluster edge probability
+     * @param[in]	pInter	inter-cluster edge probability
+     */
+    ClusteredRandomGraphGenerator(count n, count k, double pIntra, double pInter);
+
+    /**
+     * Generates a clustered random graph with the properties given in the constructor.
+     * @return The generated graph.
+     */
+    GraphW generate() override;
+
+    /**
+     * Returns the generated ground truth communities.
+     * @return The generated partition
+     */
+    Partition getCommunities();
+
+private:
+    const count n, k;
+    const double pIntra, pInter;
+    Partition zeta;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_GENERATORS_CLUSTERED_RANDOM_GRAPH_GENERATOR_HPP_

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

@@ -0,0 +1,36 @@
+#ifndef NETWORKIT_GENERATORS_CONFIGURATION_MODEL_HPP_
+#define NETWORKIT_GENERATORS_CONFIGURATION_MODEL_HPP_
+
+#include <set>
+#include <vector>
+#include <networkit/generators/StaticDegreeSequenceGenerator.hpp>
+
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * Graph generator for generating a random simple graph with exactly the given degree sequence.
+ */
+class ConfigurationModel final : public StaticDegreeSequenceGenerator {
+public:
+    /**
+     * Initializes the configuration model generator with the given degree sequence @a sequence.
+     *
+     * @param sequence std::vector<count> with the input sequence of degrees.
+     */
+    ConfigurationModel(const std::vector<count> &sequence);
+
+    /**
+     * Generates a graph according to the configuration model.
+     *
+     * @throws std::runtime_error If the sequence cannot be generated.
+     * @return The generated graph
+     */
+    GraphW generate() override;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_GENERATORS_CONFIGURATION_MODEL_HPP_

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

@@ -0,0 +1,33 @@
+/*
+ * DorogovtsevMendesGenerator.hpp
+ *
+ *  Created on: 27.05.2014
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_GENERATORS_DOROGOVTSEV_MENDES_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_DOROGOVTSEV_MENDES_GENERATOR_HPP_
+
+#include <networkit/generators/StaticGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class DorogovtsevMendesGenerator final : public StaticGraphGenerator {
+
+public:
+    /**
+     * @param nNodes number of nodes in target graph
+     */
+    DorogovtsevMendesGenerator(count nNodes);
+
+    GraphW generate() override;
+
+private:
+    count nNodes;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_DOROGOVTSEV_MENDES_GENERATOR_HPP_

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

@@ -0,0 +1,33 @@
+/*
+ * DynamicBarabasiAlbertGenerator.hpp
+ *
+ *  Created on: 09.04.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_GENERATORS_DYNAMIC_BARABASI_ALBERT_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_DYNAMIC_BARABASI_ALBERT_GENERATOR_HPP_
+
+#include <networkit/generators/DynamicGraphSource.hpp>
+
+namespace NetworKit {
+
+// FIXME: for k=2, degree 2 nodes should be most frequent but degree 4 nodes are
+/**
+ * @ingroup generators
+ */
+class DynamicBarabasiAlbertGenerator final : public DynamicGraphSource {
+
+    count k;      //!< parameter of the BA model: number of edges per new node
+    count degSum; //!< degree sum of current graph
+
+public:
+    DynamicBarabasiAlbertGenerator(count k = 2);
+
+    void initializeGraph() override;
+
+    void generate() override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_DYNAMIC_BARABASI_ALBERT_GENERATOR_HPP_

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

@@ -0,0 +1,51 @@
+/*
+ * DynamicDGSParser.hpp
+ *
+ *  Created on: Jun 17, 2013
+ *      Author: forigem
+ */
+
+#ifndef NETWORKIT_GENERATORS_DYNAMIC_DGS_PARSER_HPP_
+#define NETWORKIT_GENERATORS_DYNAMIC_DGS_PARSER_HPP_
+
+#include <iterator>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <networkit/auxiliary/StringTools.hpp>
+#include <networkit/generators/DynamicGraphSource.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class DynamicDGSParser final : public DynamicGraphSource {
+public:
+    DynamicDGSParser(const std::string &path);
+
+    /**
+     * The generator may expect the graph to be in a certain initial state. Call this method first.
+     */
+    void initializeGraph() override;
+
+    /**
+     * Perform one generative step - as defined by the implementation.
+     */
+    void generate() override;
+
+    void evaluateClusterings(const std::string &path, const Partition &clustering);
+
+private:
+    bool graphInitialized; //!< true if initializeGraph has been called and graph has been properly
+                           //!< initialized
+    std::unordered_map<std::string, node> nodeNames;
+    std::vector<std::string> nodeDates;
+    std::ifstream dgsFile;
+    std::vector<std::vector<std::string>> nodeCategories;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_DYNAMIC_DGS_PARSER_HPP_

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

@@ -0,0 +1,34 @@
+/*
+ * DynamicDorogovtsevMendesGenerator.hpp
+ *
+ *  Created on: 03.02.2014
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_GENERATORS_DYNAMIC_DOROGOVTSEV_MENDES_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_DYNAMIC_DOROGOVTSEV_MENDES_GENERATOR_HPP_
+
+#include <networkit/auxiliary/Random.hpp>
+#include <networkit/generators/DynamicGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class DynamicDorogovtsevMendesGenerator final : public DynamicGraphGenerator {
+
+public:
+    DynamicDorogovtsevMendesGenerator();
+
+    std::vector<GraphEvent> generate(count nSteps) override;
+
+private:
+    std::vector<std::pair<node, node>> edges;
+    bool initial;
+    node u; // current node
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_GENERATORS_DYNAMIC_DOROGOVTSEV_MENDES_GENERATOR_HPP_

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

@@ -0,0 +1,55 @@
+/*
+ * DynamicForestFireGenerator.hpp
+ *
+ *  Created on: 17.01.2014
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_GENERATORS_DYNAMIC_FOREST_FIRE_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_DYNAMIC_FOREST_FIRE_GENERATOR_HPP_
+
+#include <networkit/generators/DynamicGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * The Forest Fire generative model produces dynamic graphs with the following properties:
+ * - heavy tailed degree distribution
+ * - communities
+ * - densification power law
+ * - shrinking diameter
+ *
+ * see Leskovec, Kleinberg, Faloutsos: Graphs over Tim: Densification Laws,
+ *   Shringking Diameters and Possible Explanations
+ */
+class DynamicForestFireGenerator final : public DynamicGraphGenerator {
+
+public:
+    /**
+     * @param  p        "forward burning probability", controls the amount of forward connections
+     * burned by each new node
+     * @param   directed  whether the generated graph is directed or undirected
+     * @param   r         scales down the burning probability for backward connections (ignored for
+     * undirected graphs)
+     */
+    DynamicForestFireGenerator(double p, bool directed, double r = 1.0);
+
+    /**
+     * Generate event stream.
+     *
+     * @param[in]	nSteps	number of time steps in the event stream
+     */
+    std::vector<GraphEvent> generate(count nSteps) override;
+
+private:
+    double p;
+    bool directed;
+    double r;
+    bool firstCall;
+    GraphW G;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_GENERATORS_DYNAMIC_FOREST_FIRE_GENERATOR_HPP_

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

@@ -0,0 +1,40 @@
+/*
+ * DynamicGraphGenerator.hpp
+ *
+ *  Created on: 14.01.2014
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_GENERATORS_DYNAMIC_GRAPH_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_DYNAMIC_GRAPH_GENERATOR_HPP_
+
+#include <networkit/dynamics/GraphEvent.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * Abstract base class for a dynamic graph generator (in the new dynamic architecture).
+ * The generator produces a stream of events.
+ */
+class DynamicGraphGenerator {
+
+public:
+    /** Default destructor */
+    virtual ~DynamicGraphGenerator() = default;
+
+    /**
+     * Generate event stream.
+     *
+     * @param[in]	nSteps	number of time steps in the event stream
+     */
+    virtual std::vector<GraphEvent> generate(count nSteps) = 0;
+
+protected:
+    GraphW G; // the graph instance
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_GENERATORS_DYNAMIC_GRAPH_GENERATOR_HPP_

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

@@ -0,0 +1,79 @@
+/*
+ * DynamicGraphSpurce.hpp
+ *
+ *  Created on: 03.04.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_GENERATORS_DYNAMIC_GRAPH_SOURCE_HPP_
+#define NETWORKIT_GENERATORS_DYNAMIC_GRAPH_SOURCE_HPP_
+
+#include <functional>
+
+#include <networkit/dynamics/GraphEventProxy.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class DynamicGraphSource {
+
+protected:
+    GraphEventProxy *Gproxy; // receives events produced by the generator and forwards them
+    Graph *G;
+    // true if newGraph has been called and graph and proxy instances are properly set
+    bool graphSet;
+    // true if initializeGraph has been called and graph has been properly initialized
+    bool graphInitialized;
+
+public:
+    /** Default constructor */
+    DynamicGraphSource();
+
+    // DynamicGraphGenerator(GraphEventProxy& proxy);
+
+    virtual ~DynamicGraphSource() = default;
+
+    /**
+     * After constructing a DynamicGraphGenerator, call this to set a new
+     * a Graph and GraphEventProxy instance and get access to them.
+     */
+    GraphEventProxy *newGraph();
+
+    /**
+     * The generator may expect the graph to be in a certain initial state. Call this method first.
+     */
+    virtual void initializeGraph() = 0;
+
+    /**
+     * Perform one generative step - as defined by the implementation.
+     */
+    virtual void generate() = 0;
+
+    /*
+     * Continue generating while function does not return false.
+     * @param[in] cont generator continues when this function returns true
+     */
+    virtual void generateWhile(std::function<bool(void)> cont);
+
+    /**
+     * Continue generating until the number of nodes reaches this upper limit.
+     * @param[in] n  umber of nodes
+     */
+    virtual void generateNodes(count n);
+
+    /**
+     * Continue generating until the number of edges reaches this upper limit.
+     * @param[in] m  umber of edges
+     */
+    virtual void generateEdges(count m);
+
+    /**
+     * Continue generating until the number of time steps reaches this upper limit.
+     */
+    virtual void generateTimeSteps(count t);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_DYNAMIC_GRAPH_SOURCE_HPP_

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

@@ -0,0 +1,143 @@
+/*
+ * DynamicHyperbolicGenerator.hpp
+ *
+ *  Created on: 29.07.2014
+ *      Author: moritzl
+ */
+
+#ifndef NETWORKIT_GENERATORS_DYNAMIC_HYPERBOLIC_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_DYNAMIC_HYPERBOLIC_GENERATOR_HPP_
+
+#include <map>
+
+#include <networkit/generators/DynamicGraphGenerator.hpp>
+#include <networkit/generators/quadtree/Quadtree.hpp>
+
+namespace NetworKit {
+
+class DynamicHyperbolicGenerator final : public DynamicGraphGenerator {
+    friend class GeneratorsGTest;
+
+public:
+    /**
+     * Initialize a dynamic hyperbolic generator and generate initial node positions
+     * Node movement happens in discrete time steps
+     *
+     * @param n number of nodes
+     * @param avgDegree expected average degree of target graph
+     * @param exp exponent of power-law degree distribution
+     * @param T temperature parameter in edge probabilities
+     * @param moveEachStep fraction of nodes which are moved at each time step, should be
+     * non-negative
+     * @param moveDistance base value for the node movements
+     */
+
+    DynamicHyperbolicGenerator(count n = 1000, double avgDegree = 6, double exp = 3, double T = 0,
+                               double moveEachStep = 0, double moveDistance = 0);
+
+    /**
+     * Initialize a dynamic hyperbolic generator with given initial node positions in polar
+     * coordinates Node movement happens in discrete time steps
+     *
+     * @param angles angular coordinates of initial positions
+     * @param radii radial coordinates of initial positions
+     * @param R radius of hyperbolic disk
+     * @param alpha dispersion parameter of point distribution
+     * @param T temperature parameter in edge probabilities
+     * @param moveEachStep fraction of nodes which are moved at each time step, should be
+     * non-negative
+     * @param moveDistance base value for the node movements
+     */
+    DynamicHyperbolicGenerator(std::vector<double> &angles, std::vector<double> &radii, double R,
+                               double alpha, double T = 0, double moveEachStep = 0,
+                               double moveDistance = 0);
+
+    /**
+     * Default constructor
+     */
+    DynamicHyperbolicGenerator();
+
+    /**
+     * Run the dynamic, changes state of generator
+     *
+     * @param nSteps number of time steps to iterate over
+     * @return changed edges
+     */
+    std::vector<GraphEvent> generate(count nSteps) override;
+
+    /**
+     * Get the graph corresponding to the current state of the generator. Does not change the
+     * generator
+     *
+     * @return graph at the current state
+     */
+    GraphW getGraph() const;
+
+    /**
+     * Get coordinates in native representation
+     * @return vector of 2D-Points in Cartesian coordinates
+     */
+    std::vector<Point2D> getCoordinates() const;
+
+private:
+    /**
+     * Generate initial node positions and fill the quadtree with them
+     */
+    void initializePoints();
+    void initializeQuadTree();
+
+    /**
+     * Generate initial movement vectors for all points
+     */
+    void initializeMovement();
+
+    /**
+     * Generate initial movement vectors for all points
+     */
+    void recomputeBands();
+
+    vector<index> getNeighborsInBands(index i, bool bothDirections = true);
+
+    /**
+     * Execute node movement part of time step
+     *
+     * @param result vector to store GraphEvents in
+     */
+    void getEventsFromNodeMovement(vector<GraphEvent> &result);
+
+    /**
+     * Move a single node
+     *
+     * @param node Index of the node that should be moved.
+     */
+    void moveNode(index node);
+
+    // general geometry parameters
+    count nodeCount;
+    double alpha;
+    double R;
+    double T;
+
+    // movement parameters
+    double moveEachStep;
+    double moveDistance;
+
+    // coordinates
+    vector<double> angles;
+    vector<double> radii;
+
+    // movement vectors
+    vector<double> angularMovement;
+    vector<double> radialMovement;
+
+    // data structures
+    Quadtree<index, false> quad;
+    vector<double> bandRadii;
+    vector<vector<Point2DWithIndex<double>>> bands;
+    vector<vector<double>> bandAngles;
+
+    bool initialized;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_DYNAMIC_HYPERBOLIC_GENERATOR_HPP_

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

@@ -0,0 +1,26 @@
+/*
+ * DynamicPathGenerator.hpp
+ *
+ *  Created on: 14.01.2014
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_GENERATORS_DYNAMIC_PATH_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_DYNAMIC_PATH_GENERATOR_HPP_
+
+#include <networkit/generators/DynamicGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * Example dynamic graph generator: Generates a dynamically growing path.
+ */
+class DynamicPathGenerator final : public DynamicGraphGenerator {
+public:
+    std::vector<GraphEvent> generate(count nSteps) override;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_GENERATORS_DYNAMIC_PATH_GENERATOR_HPP_

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

@@ -0,0 +1,54 @@
+/*
+ * DynamicPubWebGenerator.hpp
+ *
+ *  Created on: 15.01.2014
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_GENERATORS_DYNAMIC_PUB_WEB_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_DYNAMIC_PUB_WEB_GENERATOR_HPP_
+
+#include <vector>
+
+#include <networkit/dynamics/GraphEvent.hpp>
+#include <networkit/generators/DynamicGraphGenerator.hpp>
+#include <networkit/generators/PubWebGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ */
+class DynamicPubWebGenerator final : public DynamicGraphGenerator {
+public:
+    DynamicPubWebGenerator(count numNodes, count numberOfDenseAreas, coordinate neighborhoodRadius,
+                           count maxNumberOfNeighbors, bool writeInitialGraphToStream = true);
+
+    GraphW getGraph() const { return G; }
+
+    /**
+     * Generate event stream.
+     *
+     * @param[in]  nSteps  number of time steps in the event stream
+     */
+    std::vector<GraphEvent> generate(count nSteps) override;
+
+    /// Returns a map of coordinates that were updated.
+    const std::vector<std::pair<node, Point2D>> &getNewCoordinates() const {
+        return newCoordinates;
+    }
+    std::vector<std::pair<node, Point2D>> moveNewCoordinates() { return std::move(newCoordinates); }
+
+    /// Returns a vector of the currently valid coordinates
+    const std::vector<Point2D> &getCoordinates() const { return coordinates; }
+    // no moveCoordinates, as generator needs its own copy for the next run of generate!
+
+private:
+    PubWebGenerator initGen; // multiple inheritance did not work with different generate functions
+    std::vector<std::pair<node, Point2D>> newCoordinates; //<! new and changed coordinates
+    std::vector<Point2D> coordinates;                     //<! vector of all coordinates
+    bool writeInitialGraphToStream; // if true, on first call, write initial graph to stream
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_DYNAMIC_PUB_WEB_GENERATOR_HPP_