@ladybugmem/icebug 0.1.0 → 0.1.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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