@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/edgescores/EdgeScore.hpp

@@ -0,0 +1,50 @@
+/*
+ * EdgeScore.hpp
+ *
+ *  Created on: 18.08.2015
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_EDGESCORES_EDGE_SCORE_HPP_
+#define NETWORKIT_EDGESCORES_EDGE_SCORE_HPP_
+
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+/**
+ * Abstract base class for an edge score.
+ */
+template <typename T>
+class EdgeScore : public Algorithm {
+
+public:
+    EdgeScore(const Graph &G);
+
+    /** Compute the edge score. */
+    void run() override;
+
+    /** Get a vector containing the score for each edge in the graph.
+     *
+     * @return the edge scores calculated by @ref run().
+     */
+    virtual const std::vector<T> &scores() const;
+
+    /** Get the edge score of the edge with the given edge id.
+     */
+    virtual T score(edgeid eid);
+
+    /** Get the edge score of the given edge.
+     */
+    virtual T score(node u, node v);
+
+protected:
+    const Graph *G;
+    std::vector<T> scoreData;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_EDGESCORES_EDGE_SCORE_HPP_

package/vendor/include/networkit/edgescores/EdgeScoreAsWeight.hpp

@@ -0,0 +1,33 @@
+/*
+ * EdgeScoreAsWeight.hpp
+ *
+ *  Created on: 18.11.2014
+ *      Author: Michael Hamann
+ */
+
+#ifndef NETWORKIT_EDGESCORES_EDGE_SCORE_AS_WEIGHT_HPP_
+#define NETWORKIT_EDGESCORES_EDGE_SCORE_AS_WEIGHT_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+class EdgeScoreAsWeight final {
+
+public:
+    EdgeScoreAsWeight(const GraphW &G, const std::vector<double> &score, bool squared = false,
+                      edgeweight offset = 1, edgeweight factor = 1);
+    GraphW calculate();
+
+private:
+    const GraphW *G;
+    const std::vector<double> *score;
+    bool squared;
+    edgeweight offset;
+    edgeweight factor;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_EDGESCORES_EDGE_SCORE_AS_WEIGHT_HPP_

package/vendor/include/networkit/edgescores/EdgeScoreBlender.hpp

@@ -0,0 +1,33 @@
+/*
+ * EdgeScoreBlender.hpp
+ *
+ *  Created on: 18.11.2014
+ *      Author: Michael Hamann
+ */
+
+#ifndef NETWORKIT_EDGESCORES_EDGE_SCORE_BLENDER_HPP_
+#define NETWORKIT_EDGESCORES_EDGE_SCORE_BLENDER_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+class EdgeScoreBlender final : public EdgeScore<double> {
+
+public:
+    EdgeScoreBlender(const Graph &G, const std::vector<double> &attribute0,
+                     const std::vector<double> &attribute1, const std::vector<bool> &selection);
+
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+    void run() override;
+
+private:
+    const std::vector<double> *attribute0, *attribute1;
+    const std::vector<bool> *selection;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_EDGESCORES_EDGE_SCORE_BLENDER_HPP_

package/vendor/include/networkit/edgescores/EdgeScoreLinearizer.hpp

@@ -0,0 +1,32 @@
+/*
+ * EdgeScoreLinearizer.hpp
+ *
+ *  Created on: 18.11.2014
+ *      Author: Michael Hamann
+ */
+
+#ifndef NETWORKIT_EDGESCORES_EDGE_SCORE_LINEARIZER_HPP_
+#define NETWORKIT_EDGESCORES_EDGE_SCORE_LINEARIZER_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+class EdgeScoreLinearizer final : public EdgeScore<double> {
+
+private:
+    const std::vector<double> *attribute;
+    bool inverse;
+
+public:
+    EdgeScoreLinearizer(const Graph &graph, const std::vector<double> &attribute,
+                        bool inverse = false);
+
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+    void run() override;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_EDGESCORES_EDGE_SCORE_LINEARIZER_HPP_

package/vendor/include/networkit/edgescores/EdgeScoreNormalizer.hpp

@@ -0,0 +1,35 @@
+/*
+ * EdgeScoreNormalizer.hpp
+ *
+ *  Created on: 18.11.2014
+ *      Author: Michael Hamann
+ */
+
+#ifndef NETWORKIT_EDGESCORES_EDGE_SCORE_NORMALIZER_HPP_
+#define NETWORKIT_EDGESCORES_EDGE_SCORE_NORMALIZER_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+template <typename A>
+class EdgeScoreNormalizer final : public EdgeScore<double> {
+
+public:
+    EdgeScoreNormalizer(const Graph &G, const std::vector<A> &score, bool invert = false,
+                        double lower = 0, double upper = 1.0);
+
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+    void run() override;
+
+private:
+    const std::vector<A> *input;
+    bool invert;
+    double lower, upper;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_EDGESCORES_EDGE_SCORE_NORMALIZER_HPP_

package/vendor/include/networkit/edgescores/GeometricMeanScore.hpp

@@ -0,0 +1,29 @@
+/*
+ * GeometricMeanScore.hpp
+ *
+ *  Created on: 18.11.2014
+ *      Author: Michael Hamann
+ */
+
+#ifndef NETWORKIT_EDGESCORES_GEOMETRIC_MEAN_SCORE_HPP_
+#define NETWORKIT_EDGESCORES_GEOMETRIC_MEAN_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+class GeometricMeanScore final : public EdgeScore<double> {
+
+private:
+    const std::vector<double> *attribute;
+
+public:
+    GeometricMeanScore(const Graph &G, const std::vector<double> &attribute);
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+    void run() override;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_EDGESCORES_GEOMETRIC_MEAN_SCORE_HPP_

package/vendor/include/networkit/edgescores/PrefixJaccardScore.hpp

@@ -0,0 +1,23 @@
+#ifndef NETWORKIT_EDGESCORES_PREFIX_JACCARD_SCORE_HPP_
+#define NETWORKIT_EDGESCORES_PREFIX_JACCARD_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+template <typename AttributeT>
+class PrefixJaccardScore final : public EdgeScore<double> {
+
+public:
+    PrefixJaccardScore(const Graph &G, const std::vector<AttributeT> &attribute);
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+    void run() override;
+
+private:
+    const std::vector<AttributeT> *inAttribute;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_EDGESCORES_PREFIX_JACCARD_SCORE_HPP_

package/vendor/include/networkit/edgescores/TriangleEdgeScore.hpp

@@ -0,0 +1,39 @@
+/*
+ * TriangleEdgeScore.hpp
+ *
+ *  Created on: 22.05.2014
+ *      Author: Gerd Lindner, Michael Hamann
+ */
+
+#ifndef NETWORKIT_EDGESCORES_TRIANGLE_EDGE_SCORE_HPP_
+#define NETWORKIT_EDGESCORES_TRIANGLE_EDGE_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+/**
+ * A parallel triangle counting implementation based on ideas in [0].
+ *
+ * This implementation avoids less work but needs therefore also less checks and
+ * is (apart from a fast initialization) parallel without any locks. In experiments
+ * this implementation seems to be fast both in non-parallel as well as in parallel
+ * settings. With only one thread its performance is similar to the sequential
+ * ChibaNishizekiTriangleEdgeScore in NetworKit.
+ *
+ * [0] Triangle Listing Algorithms: Back from the Diversion
+ * Mark Ortmann and Ulrik Brandes * 2014 Proceedings of the Sixteenth Workshop on Algorithm
+ * Engineering and Experiments (ALENEX). 2014, 1-8
+ */
+class TriangleEdgeScore final : public EdgeScore<count> {
+
+public:
+    TriangleEdgeScore(const Graph &G);
+    count score(edgeid eid) override;
+    count score(node u, node v) override;
+    void run() override;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_EDGESCORES_TRIANGLE_EDGE_SCORE_HPP_

package/vendor/include/networkit/embedding/Node2Vec.hpp

@@ -0,0 +1,83 @@
+/*
+ *  Node2Vec.hpp
+ *
+ *
+ *  Created on: 29.09.2020
+ *      Author: Klaus Ahrens
+ *              <ahrens@informatik.hu-berlin.de>
+ *
+ *  adapted and reimplemented from node2vec
+ *  part of snap [https://github.com/snap-stanford/snap]
+ *  Copyright (c) 2007-2019, Jure Leskovec (under BSD license)
+ *
+ *  see [https://arxiv.org/pdf/1607.00653v1.pdf]
+ */
+
+#ifndef NETWORKIT_EMBEDDING_NODE2_VEC_HPP_
+#define NETWORKIT_EMBEDDING_NODE2_VEC_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup embedding
+ *
+ * Feature extraction by node2vec algorithm.
+ */
+class Node2Vec final : public Algorithm {
+
+public:
+    /**
+     * Node2Vec learns embeddings for nodes in a graph by optimizing a neighborhood preserving
+     * objective. In order to achieve this, biased random walks are initiated for every node and the
+     * result is of probabilistic nature. Several input parameters control the specific behavior of
+     * the random walks. Amongst others Node2Vec is able to produce embeddings for visualization
+     * (D=2 or D=3) and machine learning (D=128 [default]). Both directed and undirected graphs
+     * withouth isolated nodes are supported.
+     *
+     * This implementation is an adaption of the original code from snap:
+     * https://github.com/snap-stanford/snap
+     *
+     * @param G     The graph.
+     * @param P     Walk Return parameter (stay local).
+     * @param Q     Walk In-Out parameter (drift away).
+     * @param L     Walk length.
+     * @param N     Walk count.
+     * @param D     Dimension of embedding vectors.
+     */
+    Node2Vec(const Graph &G, double P = 1, double Q = 1, count L = 80, count N = 10, count D = 128);
+
+    ~Node2Vec() override = default;
+
+    /**
+     This method computes all node embeddings.
+    */
+    void run() override;
+
+    /**
+     This method returns a vector that contains feature vectors for all nodes
+    */
+    const std::vector<std::vector<float>> &getFeatures() const;
+
+private:
+    // The graph
+    const Graph *G;
+    // Walk parameter P
+    double P;
+    // Walk parameter Q
+    double Q;
+    // Walk length L
+    count L;
+    // Walk count N
+    count N;
+    // Feature Dimension D
+    count D;
+
+    std::vector<std::vector<float>> features;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_EMBEDDING_NODE2_VEC_HPP_

package/vendor/include/networkit/flow/EdmondsKarp.hpp

@@ -0,0 +1,112 @@
+/*
+ * EdmondsKarp.hpp
+ *
+ *  Created on: 11.06.2014
+ *      Author: Michael Wegner (michael.wegner@student.kit.edu), Michael Hamann
+ * <michael.hamann@kit.edu>
+ */
+
+#ifndef NETWORKIT_FLOW_EDMONDS_KARP_HPP_
+#define NETWORKIT_FLOW_EDMONDS_KARP_HPP_
+
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup flow
+ * The EdmondsKarp class implements the maximum flow algorithm by Edmonds and Karp.
+ */
+class EdmondsKarp final : public Algorithm {
+    const Graph *graph;
+
+    node source, sink;
+
+    std::vector<edgeweight> flow;
+    edgeweight flowValue;
+
+public:
+    /**
+     * Constructs an instance of the EdmondsKarp algorithm for the given graph, source and sink
+     * @param graph The graph.
+     * @param source The source node.
+     * @param sink The sink node.
+     */
+    EdmondsKarp(const Graph &graph, node source, node sink);
+
+    /**
+     * Computes the maximum flow, executes the EdmondsKarp algorithm.
+     */
+    void run() override;
+
+    /**
+     * Returns the value of the maximum flow from source to sink.
+     *
+     * @return The maximum flow value
+     */
+    edgeweight getMaxFlow() const;
+
+    /**
+     * Returns the set of the nodes on the source side of the flow/minimum cut.
+     *
+     * @return The set of nodes that form the (smallest) source side of the flow/minimum cut.
+     */
+    std::vector<node> getSourceSet() const;
+
+    /**
+     * Get the flow value between two nodes @a u and @a v.
+     * @warning The running time of this function is linear in the degree of u.
+     *
+     * @param u The first node
+     * @param v The second node
+     * @return The flow between node u and v.
+     */
+    edgeweight getFlow(node u, node v) const;
+
+    /**
+     * Get the flow value of an edge.
+     *
+     * @param eid The id of the edge
+     * @return The flow on the edge identified by eid
+     */
+    edgeweight getFlow(edgeid eid) const {
+        assureFinished();
+        return flow[eid];
+    };
+
+    /**
+     * Return a copy of the flow values of all edges.
+     * @note Instead of copying all values you can also use the inline function "getFlow(edgeid)" in
+     * order to access the values efficiently.
+     *
+     * @return The flow values of all edges
+     */
+    const std::vector<edgeweight> &getFlowVector() const;
+
+private:
+    void runUndirected();
+    void runDirected();
+
+    /**
+     * Performs an undirected breadth-first search on the graph from the source node to find
+     * an augmenting path to the sink node respecting the flow values
+     * @param pred Used to store the path from the source to the sink.
+     * @return The gain in terms of flow.
+     */
+    edgeweight BFS(std::vector<node> &pred) const;
+
+    /**
+     * Performs a directed breadth-first search on the graph from the source node to find
+     * an augmenting path to the sink node respecting the flow values
+     * @param pred Used to store the path from the source to the sink.
+     * @return The gain in terms of flow.
+     */
+    edgeweight directedBFS(const std::vector<count> &reverseEdges, std::vector<node> &pred) const;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_FLOW_EDMONDS_KARP_HPP_

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

@@ -0,0 +1,87 @@
+/*
+ * BarabasiAlbertGenerator.hpp
+ *
+ *  Created on: May 28, 2013
+ *      Author: forigem
+ */
+
+#ifndef NETWORKIT_GENERATORS_BARABASI_ALBERT_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_BARABASI_ALBERT_GENERATOR_HPP_
+
+#include <networkit/generators/StaticGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * Generates a scale-free graph using the Barabasi-Albert preferential attachment model.
+ */
+class BarabasiAlbertGenerator final : public StaticGraphGenerator {
+    GraphW initGraph;
+    count k{0};      //!< Attachments made per node
+    count nMax{0};   //!< The maximal number of nodes attached
+    count n0{0};     //!< The number of initial connected nodes
+    bool sequential; //!< Specifies whether to compute sequentially using batagelj's method or in
+                     //!< parallel (if the number of threads allow for it).
+
+    GraphW generateParallel();
+    GraphW generateBatagelj();
+
+public:
+    BarabasiAlbertGenerator() = default;
+
+    /**
+     * This generator uses the preferential attachment model as introduced by Barabasi and
+     * Albert[1], implemented in the much faster method from Batagelj and Brandes[2] per default
+     * where the running time is O(n+m). Furthermore there is a parallel version from Sanders and
+     * Schulz[3] implemented. This implementation can be selected by setting sequential=false.
+     * Empirically, the parallel version shows better runtimes (when executed multi-threaded).
+     *
+     * [1] Barabasi, Albert: [Emergence of Scaling in Random Networks]
+     *   (http://arxiv.org/pdf/cond-mat/9910332.pdf)
+     * [2] ALG 5 of Batagelj, Brandes: [Efficient Generation of Large Random Networks]
+     *   (https://kops.uni-konstanz.de/bitstream/handle/123456789/5799/random.pdf?sequence=1)
+     * [3] Peter Sanders, Christian Schulz: [Scalable generation of scale-free graphs]
+     *   (https://www.sciencedirect.com/science/article/pii/S0020019016300102)
+     *
+     * The generator will emit a simple graph, where all
+     * new nodes are initially connected to k random neighbors.
+     *
+     * @param k     Number of attachments per node
+     * @param nMax  Number of nodes in the graph
+     * @param n0    Number of connected nodes to begin with
+     * @param sequential Specifies whether to use Batagelj and Brandes's method (sequential) or a
+     * parallel variant. Default: true.
+     */
+    BarabasiAlbertGenerator(count k, count nMax, count n0 = 0, bool sequential = true);
+
+    /**
+     * This generator uses the preferential attachment model as introduced by Barabasi and
+     * Albert[1], implemented in the much faster method from Batagelj and Brandes[2] per default
+     * where the running time is O(n+m). Furthermore there is a parallel version from Sanders and
+     * Schulz[3] implemented. This implementation can be selected by setting sequential=false.
+     * Empirically, the parallel version shows better runtimes (when executed multi-threaded).
+     *
+     * [1] Barabasi, Albert: [Emergence of Scaling in Random Networks]
+     *   (http://arxiv.org/pdf/cond-mat/9910332.pdf)
+     * [2] ALG 5 of Batagelj, Brandes: [Efficient Generation of Large Random Networks]
+     *   (https://kops.uni-konstanz.de/bitstream/handle/123456789/5799/random.pdf?sequence=1)
+     * [3] Peter Sanders, Christian Schulz: [Scalable generation of scale-free graphs]
+     *   (https://www.sciencedirect.com/science/article/pii/S0020019016300102)
+     *
+     * The generator will emit a simple graph, where all
+     * new nodes are initially connected to k random neighbors.
+     *
+     * @param k     Number of attachments per node
+     * @param nMax  Number of nodes in the graph
+     * @param initGraph   The initial graph to start from
+     * @param sequential Specifies whether to use Batagelj and Brandes's method (sequential) or a
+     * parallel variant. Default: true.
+     */
+    BarabasiAlbertGenerator(count k, count nMax, const Graph &initGraph, bool sequential = true);
+
+    GraphW generate() override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_BARABASI_ALBERT_GENERATOR_HPP_

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

@@ -0,0 +1,46 @@
+/*
+ * ChungLu.hpp
+ *
+ *  Created on: Dec 23, 2013
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_GENERATORS_CHUNG_LU_GENERATOR_HPP_
+#define NETWORKIT_GENERATORS_CHUNG_LU_GENERATOR_HPP_
+
+#include <networkit/generators/StaticDegreeSequenceGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * Given an arbitrary degree sequence, the Chung-Lu generative model
+ * will produce a random graph with the same expected degree sequence.
+ *
+ * see Chung, Lu: The average distances in random graphs with given expected degrees
+ * and Chung, Lu: Connected Components in Random Graphs with Given Expected Degree Sequences.
+ * Aiello, Chung, Lu: A Random Graph Model for Massive Graphs describes a different generative model
+ * which is basically asymptotically equivalent but produces multi-graphs.
+ *
+ * This follows the implementation of Joel Miller and Aric Hagberg's
+ * "Efficient Generation of Networks with Given Expected Degrees" (2011)
+ * http://aric.hagberg.org/papers/miller-2011-efficient.pdf .
+ * It gives a complexity of O(n+m) as opposed to quadratic.
+ *
+ */
+
+class ChungLuGenerator final : public StaticDegreeSequenceGenerator {
+    count sum_deg;
+    count n;
+
+public:
+    ChungLuGenerator(const std::vector<count> &degreeSequence);
+
+    /**
+     * Generates graph with expected degree sequence seq.
+     */
+    GraphW generate() override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_CHUNG_LU_GENERATOR_HPP_

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

@@ -0,0 +1,63 @@
+/*
+ * ChungLuGeneratorAlamEtAl.hpp
+ *
+ *  Created on: Dec 23, 2013
+ *      Author: Henning
+ *      Contributors: Hoske/Weisbarth/Hering
+ */
+
+#ifndef NETWORKIT_GENERATORS_CHUNG_LU_GENERATOR_ALAM_ET_AL_HPP_
+#define NETWORKIT_GENERATORS_CHUNG_LU_GENERATOR_ALAM_ET_AL_HPP_
+
+#include <networkit/generators/StaticDegreeSequenceGenerator.hpp>
+#include <networkit/generators/StaticGraphGenerator.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup generators
+ * The Chung-Lu generative model produces a random graph for a given expected degree sequence.
+ * For reference, see the original model proposed by Chung and Lu in [1] and [2].
+ * This implementation follows a newer parallelizable algorithm [3] by M. Alam, M. Khan et al.:
+ * The time complexity is O(m/p + delta + p), where m is the number of edges, p are the number of
+ * threads, and delta is the number of distinct node degrees from the input sequence. Furthermore
+ * the space complexity is O(delta) for each of the p threads.
+ *
+ * [1] F. Chung, L. Lu: [The Average Distance in a Random Graph with Given Expected
+ * Degree](https://www.researchgate.net/publication/11004006_The_Average_Distance_in_a_Random_Graph_with_Given_Expected_Degree)
+ *
+ * [2] F. Chung, L. Lu: [Connected Components in Random Graphs with Given Expected Degree
+ * Sequences](https://link.springer.com/article/10.1007/PL00012580)
+ *
+ * [3] M. Alam, M. Khan, et al.: [An Efficient and Scalable Algorithmic Method for Generating
+ * Large-Scale Random Graphs](https://ieeexplore.ieee.org/document/7877110)
+ */
+
+class ChungLuGeneratorAlamEtAl final : StaticGraphGenerator {
+    struct VertexGroup {
+        count degrees;
+        count vertexCount;
+        count startIndex;
+    };
+    std::vector<VertexGroup> groups;
+    count sum_deg;
+    count n;
+    bool parallel;
+
+    template <typename F>
+    void edgeSkipping(std::mt19937_64 &generator, F &&addEdge, index i, index j, double p,
+                      index end);
+    GraphW generateSequential();
+    GraphW generateParallel();
+
+public:
+    ChungLuGeneratorAlamEtAl(const std::vector<count> &degreeSequence, bool parallel = false);
+
+    /**
+     * Generates graph with expected degree sequence seq.
+     */
+    GraphW generate() override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GENERATORS_CHUNG_LU_GENERATOR_ALAM_ET_AL_HPP_