@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/graph/UnionMaximumSpanningForest.hpp

@@ -0,0 +1,126 @@
+#ifndef NETWORKIT_GRAPH_UNION_MAXIMUM_SPANNING_FOREST_HPP_
+#define NETWORKIT_GRAPH_UNION_MAXIMUM_SPANNING_FOREST_HPP_
+
+#include <networkit/auxiliary/Log.hpp>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/GraphW.hpp>
+#include <networkit/structures/UnionFind.hpp>
+
+namespace NetworKit {
+
+/**
+ * Union maximum-weight spanning forest algorithm, computes the union of all maximum-weight spanning
+ * forests using Kruskal's algorithm.
+ */
+class UnionMaximumSpanningForest final : public Algorithm {
+public:
+    /**
+     * Initialize the union maximum-weight spanning forest algorithm, uses edge weights.
+     *
+     * @param G The input graph.
+     */
+    UnionMaximumSpanningForest(const Graph &G);
+
+    /**
+     * Initialize the union maximum-weight spanning forest algorithm using an attribute as edge
+     * weight.
+     *
+     * This copies the attribute values, the supplied attribute vector is not stored.
+     *
+     * @param G The input graph.
+     * @param attribute The attribute to use, can be either of type edgeweight (double) or count
+     * (uint64), internally all values are handled as double.
+     */
+    template <typename A>
+    UnionMaximumSpanningForest(const Graph &G, const std::vector<A> &attribute);
+
+    /**
+     * Execute the algorithm. The algorithm is not parallel.
+     */
+    void run() override;
+
+    /**
+     * Get a boolean attribute that indicates for each edge if it is part of any maximum-weight
+     * spanning forest.
+     *
+     * This attribute is only calculated and can thus only be request if the supplied graph has edge
+     * ids.
+     *
+     * @param move If the attribute shall be moved out of the algorithm instance.
+     * @return The vector with the boolean attribute for each edge.
+     */
+    std::vector<bool> getAttribute(bool move = false);
+
+    /**
+     * Checks if the edge (@a u, @a v) is part of any maximum-weight spanning forest.
+     *
+     * @param u The first node of the edge to check
+     * @param v The second node of the edge to check
+     * @return If the edge is part of any maximum-weight spanning forest.
+     */
+    bool inUMSF(node u, node v) const;
+
+    /**
+     * Checks if the edge with the id @a eid is part of any maximum-weight spanning forest.
+     *
+     * @param eid The id of the edge to check.
+     * @return If the edge is part of any maximum-weight spanning forest.
+     */
+    bool inUMSF(edgeid eid) const;
+
+    /**
+     * Gets the union of all maximum-weight spanning forests as graph.
+     *
+     * @param move If the graph shall be moved out of the algorithm instance.
+     * @return The calculated union of all maximum-weight spanning forests.
+     */
+    GraphW getUMSF(bool move = false);
+
+private:
+    struct weightedEdge {
+        edgeweight attribute;
+        node u;
+        node v;
+        edgeid eid;
+
+        bool operator>(const weightedEdge &other) const {
+            return (attribute > other.attribute)
+                   || (attribute == other.attribute
+                       && (u > other.u || (u == other.u && v > other.v)));
+        };
+        weightedEdge(node u, node v, edgeweight attribute, edgeid eid = 0)
+            : attribute(attribute), u(u), v(v), eid(eid){};
+    };
+
+    const Graph *G;
+    std::vector<weightedEdge> weightedEdges;
+
+    GraphW umsf;
+    std::vector<bool> umsfAttribute;
+
+    bool hasWeightedEdges;
+    bool hasUMSF;
+    bool hasAttribute;
+};
+
+template <typename A>
+UnionMaximumSpanningForest::UnionMaximumSpanningForest(const Graph &G,
+                                                       const std::vector<A> &attribute)
+    : G(&G), hasWeightedEdges(false), hasUMSF(false), hasAttribute(false) {
+    if (!G.hasEdgeIds()) {
+        throw std::runtime_error("Error: Edges of G must be indexed for using edge attributes");
+    }
+
+    weightedEdges.reserve(G.numberOfEdges());
+
+    G.forEdges(
+        [&](node u, node v, edgeid eid) { weightedEdges.emplace_back(u, v, attribute[eid], eid); });
+
+    INFO(weightedEdges.size(), " weighted edges saved");
+
+    hasWeightedEdges = true;
+}
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_GRAPH_UNION_MAXIMUM_SPANNING_FOREST_HPP_

package/vendor/include/networkit/graph/test/GraphBuilderBenchmark.hpp

@@ -0,0 +1,68 @@
+/*
+ * GraphBuilderBenchmark.hpp
+ *
+ *  Created on: 04.12.2014
+ *      Author: Marvin Ritter (marvin.ritter@gmail.com)
+ */
+
+#ifndef NETWORKIT_GRAPH_TEST_GRAPH_BUILDER_BENCHMARK_HPP_
+#define NETWORKIT_GRAPH_TEST_GRAPH_BUILDER_BENCHMARK_HPP_
+
+#include <functional>
+#include <gtest/gtest.h>
+#include <networkit/auxiliary/Timer.hpp>
+
+namespace NetworKit {
+
+class GTestBenchmark : public testing::Test {
+public:
+    static void measureInMs(std::function<int()> func, int iterations = 1) {
+        Aux::Timer timer;
+        std::vector<unsigned long long> runningTimes(iterations);
+        for (int i = 0; i < iterations; i++) {
+            printf("Iteration %d of %d ...", i + 1, iterations);
+
+            timer.start();
+            int x = func();
+            timer.stop();
+
+            runningTimes[i] = timer.elapsedMilliseconds();
+
+            printf("done (took %llu ms, result: %d).\n", runningTimes[i], x);
+        }
+
+        long long unsigned sum = 0;
+        long long unsigned min = runningTimes[0];
+        long long unsigned max = runningTimes[0];
+        for (auto t : runningTimes) {
+            sum += t;
+            if (t < min)
+                min = t;
+            if (t > max)
+                max = t;
+        }
+
+        printf("Iterations: %d, average runtime: %1.1f ms, fastest run: %llu ms, slowest run: %llu "
+               "ms\n",
+               iterations, (double)sum / iterations, min, max);
+    }
+
+    template <typename L>
+    uint64_t timeOnce(L f) {
+        // TODO should be moved somewhere else (Benchmark parent class or the Timer class itself)
+        Aux::Timer timer;
+        timer.start();
+        f();
+        timer.stop();
+        return timer.elapsedMilliseconds();
+    }
+};
+
+class GraphBuilderBenchmark : public GTestBenchmark {
+public:
+    GraphBuilderBenchmark() = default;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_GRAPH_TEST_GRAPH_BUILDER_BENCHMARK_HPP_

package/vendor/include/networkit/independentset/IndependentSetFinder.hpp

@@ -0,0 +1,44 @@
+/*
+ * IndependentSetFinder.hpp
+ *
+ *  Created on: 27.02.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_INDEPENDENTSET_INDEPENDENT_SET_FINDER_HPP_
+#define NETWORKIT_INDEPENDENTSET_INDEPENDENT_SET_FINDER_HPP_
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup independentset
+ *
+ * Abstract base class for independent set algorithms.
+ */
+class IndependentSetFinder {
+
+public:
+    /** Default destructor */
+    virtual ~IndependentSetFinder() = default;
+
+    /**
+     * Returns a boolean vector of length n where vec[v] is @c true iff v is in the independent
+     * sets.
+     * @param[in]  G  The graph.
+     * @return A boolean vector of length n.
+     */
+    virtual std::vector<bool> run(const Graph &G) = 0;
+
+    /**
+     * Checks whether a set is independent.
+     * @param set The set which is supposed to be independent.
+     * @param The graph.
+     * @return @c true iff @a set is independent.
+     */
+    bool isIndependentSet(const std::vector<bool> &set, const Graph &G) const;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_INDEPENDENTSET_INDEPENDENT_SET_FINDER_HPP_

package/vendor/include/networkit/independentset/Luby.hpp

@@ -0,0 +1,27 @@
+/*
+ * Luby.hpp
+ *
+ *  Created on: 27.02.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_INDEPENDENTSET_LUBY_HPP_
+#define NETWORKIT_INDEPENDENTSET_LUBY_HPP_
+
+#include <networkit/independentset/IndependentSetFinder.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup independentset
+ *
+ * Luby's parallel independent set algorithm for undirected graphs.
+ */
+class Luby final : public IndependentSetFinder {
+
+public:
+    std::vector<bool> run(const Graph &G) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_INDEPENDENTSET_LUBY_HPP_

package/vendor/include/networkit/io/BinaryEdgeListPartitionReader.hpp

@@ -0,0 +1,45 @@
+
+#ifndef NETWORKIT_IO_BINARY_EDGE_LIST_PARTITION_READER_HPP_
+#define NETWORKIT_IO_BINARY_EDGE_LIST_PARTITION_READER_HPP_
+
+#include <string>
+
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * Reads a partition file that contains a binary list of pairs (node, partition(node)).
+ * It is assumed that all integers are unsigned.
+ *
+ * @ingroup io
+ */
+class BinaryEdgeListPartitionReader final {
+
+public:
+    /**
+     * Constructs the BinaryEdgeListPartitionReader class with @a firstNode as the id of the node
+     * that shall become node 0 and @a width the width of the integers read.
+     * @param[in] firstNode Index of the first node in the file.
+     * @param[in] width The width of the read integers (supported values: 4, 8)
+     */
+    BinaryEdgeListPartitionReader(node firstNode = 0, uint8_t width = 4);
+
+    /**
+     * Read a partition from a file. File format:
+     * binary list of pairs (node, partition(node))
+     * Partition ids must be in the range [0, max(uint64_t)).
+     *
+     * @param[in] path Path to file or to several files (which are read in order).
+     * @return The partition contained in the file at @a path.
+     */
+    Partition read(std::string_view path);
+
+    Partition read(const std::vector<std::string> &paths);
+
+    node firstNode;
+    uint8_t width;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_BINARY_EDGE_LIST_PARTITION_READER_HPP_

package/vendor/include/networkit/io/BinaryEdgeListPartitionWriter.hpp

@@ -0,0 +1,47 @@
+/**
+ * BinaryEdgeListPartitionWriter.hpp
+ *
+ * @author Michael Hamann
+ */
+
+#ifndef NETWORKIT_IO_BINARY_EDGE_LIST_PARTITION_WRITER_HPP_
+#define NETWORKIT_IO_BINARY_EDGE_LIST_PARTITION_WRITER_HPP_
+
+#include <string>
+
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Writes a partition to a file that contains a binary list of pairs (node, partition(node)).
+ * All integers are unsigned integers.
+ */
+class BinaryEdgeListPartitionWriter final {
+public:
+    /**
+     * Constructs the BinaryEdgeListPartitionWriter class with @a firstNode as the id of the
+     * first node (i.e., this value is added to all node ids before writing) using unsigned
+     * integers with the given @a width.
+     *
+     * @param[in] firstNode The id of node 0, all other node ids are adjusted accordingly.
+     * @param[in] width The width of the written integers (supported values: 4, 8).
+     */
+    BinaryEdgeListPartitionWriter(node firstNode = 0, uint8_t width = 4);
+
+    /**
+     * Write the given partition @a zeta to the given @a path.
+     *
+     * @param[in] zeta The partition to write.
+     * @param[in] path The path to write to.
+     */
+    void write(Partition &zeta, std::string_view path) const;
+
+private:
+    node firstNode;
+    uint8_t width;
+};
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_IO_BINARY_EDGE_LIST_PARTITION_WRITER_HPP_

package/vendor/include/networkit/io/BinaryPartitionReader.hpp

@@ -0,0 +1,41 @@
+/*
+ * BinaryPartitionReader.hpp
+ *
+ *  Created on: 12.04.2017
+ *      Author: Michael Hamann
+ */
+
+#ifndef NETWORKIT_IO_BINARY_PARTITION_READER_HPP_
+#define NETWORKIT_IO_BINARY_PARTITION_READER_HPP_
+
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class BinaryPartitionReader final {
+
+public:
+    /**
+     * Construct a binary partition reader.
+     *
+     * @param[in]  width  The integer width. Supported values: 4 and 8.
+     */
+    BinaryPartitionReader(uint8_t width = 4);
+
+    /**
+     * Read a partition from a file. File format:
+     *     list of (unsigned) integer partition ids, one for every node
+     *
+     * @param[in]  path  Path to file.
+     */
+    Partition read(std::string_view path);
+
+private:
+    uint8_t width;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_BINARY_PARTITION_READER_HPP_

package/vendor/include/networkit/io/BinaryPartitionWriter.hpp

@@ -0,0 +1,44 @@
+/**
+ * BinaryPartitionWriter.hpp
+ *
+ * @author Michael Hamann
+ */
+
+#ifndef NETWORKIT_IO_BINARY_PARTITION_WRITER_HPP_
+#define NETWORKIT_IO_BINARY_PARTITION_WRITER_HPP_
+
+#include <string>
+
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Writes a partition to a file that contains a binary list of partition ids.
+ * Partition ids are unsigned integers.
+ */
+class BinaryPartitionWriter final {
+public:
+    /**
+     * Constructs the BinaryPartitionWriter class using unsigned integers
+     * of width @a width for the written partition ids.
+     *
+     * @param[in] width The width of the written integers (supported values: 4, 8, default: 4).
+     */
+    BinaryPartitionWriter(uint8_t width = 4);
+
+    /**
+     * Write the given partition @a zeta to the given @a path.
+     *
+     * @param[in] zeta The partition to write.
+     * @param[in] path The path to write to.
+     */
+    void write(const Partition &zeta, std::string_view path) const;
+
+private:
+    uint8_t width;
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_IO_BINARY_PARTITION_WRITER_HPP_

package/vendor/include/networkit/io/CoverReader.hpp

@@ -0,0 +1,27 @@
+
+#ifndef NETWORKIT_IO_COVER_READER_HPP_
+#define NETWORKIT_IO_COVER_READER_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Cover.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class CoverReader {
+public:
+    /**
+     * Read a cover from a file. File format: each line contains the node ids of one subset.
+     *
+     * @param[in]  path  The path to the input file
+     * @param[in]  G     The graph for which the cover shall be read
+     * @return The cover instance
+     */
+    virtual Cover read(std::string_view path, Graph &G);
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_IO_COVER_READER_HPP_

package/vendor/include/networkit/io/CoverWriter.hpp

@@ -0,0 +1,21 @@
+
+#ifndef NETWORKIT_IO_COVER_WRITER_HPP_
+#define NETWORKIT_IO_COVER_WRITER_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Cover.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Write a clustering to a file.
+ */
+
+class CoverWriter final {
+public:
+    void write(Cover &zeta, std::string_view path) const;
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_IO_COVER_WRITER_HPP_

package/vendor/include/networkit/io/DGSReader.hpp

@@ -0,0 +1,39 @@
+/*
+ * DGSReader.hpp
+ *
+ *  Created on: 01.06.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_IO_DGS_READER_HPP_
+#define NETWORKIT_IO_DGS_READER_HPP_
+
+#include <fstream>
+#include <string>
+
+#include <networkit/io/DynamicGraphReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * DGS is a file format allowing to store graphs and dynamic graphs in a textual human readable way,
+ * yet with a small size allowing to store large graphs. Graph dynamics is defined using events like
+ * adding, deleting or changing a node or edge. With DGS, graphs will therefore be seen as stream of
+ *  such events.
+ *
+ * Format documentation: http://graphstream-project.org/doc/Advanced-Concepts/The-DGS-File-Format/
+ *
+ */
+class DGSReader final : public DynamicGraphReader {
+
+public:
+    /**
+     * @param[in]  path  Path to file in DGS format.
+     * @param[in]  Gproxy  Graph event proxy receives the events from the file.
+     */
+    void read(std::string path, GraphEventProxy &Gproxy) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_DGS_READER_HPP_

package/vendor/include/networkit/io/DibapGraphReader.hpp

@@ -0,0 +1,43 @@
+/*
+ * DibapGraphReader.hpp
+ *
+ *  Created on: Jun 12, 2013
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_IO_DIBAP_GRAPH_READER_HPP_
+#define NETWORKIT_IO_DIBAP_GRAPH_READER_HPP_
+
+#ifndef NETWORKIT_WINDOWS
+
+#include <vector>
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/io/GraphReader.hpp>
+#include <networkit/viz/Point.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * TODO: class documentation
+ */
+class DibapGraphReader final : public GraphReader {
+public:
+    DibapGraphReader() = default;
+
+    GraphW read(std::string_view path) override;
+
+    const std::vector<Point<coordinate>> &getCoordinates() const noexcept { return coordinates; }
+
+    std::vector<Point<coordinate>> moveCoordinates() { return std::move(coordinates); }
+
+private:
+    std::vector<Point<coordinate>> coordinates;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_WINDOWS
+
+#endif // NETWORKIT_IO_DIBAP_GRAPH_READER_HPP_

package/vendor/include/networkit/io/DotGraphWriter.hpp

@@ -0,0 +1,39 @@
+/*
+ * DotGraphWriter.hpp
+ *
+ *  Created on: Jun 5, 2013
+ *      Author: forigem
+ */
+
+#ifndef NETWORKIT_IO_DOT_GRAPH_WRITER_HPP_
+#define NETWORKIT_IO_DOT_GRAPH_WRITER_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/io/GraphWriter.hpp>
+
+namespace NetworKit {
+
+/**
+
+ * @ingroup io
+ *
+ * This class turns a graph into a very basic GraphViz file as documented in the official manual
+ [1].
+ * If a more thorough support is desired, please contact the developers:
+ https://github.com/networkit/networkit
+ *
+ * [1] https://graphviz.gitlab.io/_pages/pdf/dotguide.pdf
+ */
+class DotGraphWriter final : public GraphWriter {
+public:
+    /**
+     * Write a graph as a GraphViz/file.
+     *
+     * @param[in]	graph	The graph object
+     * @param[in]	path	The file path to be written to
+     */
+    void write(const Graph &G, std::string_view path) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_DOT_GRAPH_WRITER_HPP_

package/vendor/include/networkit/io/DotPartitionWriter.hpp

@@ -0,0 +1,23 @@
+
+#ifndef NETWORKIT_IO_DOT_PARTITION_WRITER_HPP_
+#define NETWORKIT_IO_DOT_PARTITION_WRITER_HPP_
+
+#include <map>
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class DotPartitionWriter final {
+public:
+    void write(Graph &graph, Partition &zeta, std::string_view path) const;
+
+    std::map<index, double> createHueMap(Graph &graph, Partition &zeta) const;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_DOT_PARTITION_WRITER_HPP_

package/vendor/include/networkit/io/DynamicGraphReader.hpp

@@ -0,0 +1,29 @@
+/*
+ * DynamicGraphReader.hpp
+ *
+ *  Created on: 01.06.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_IO_DYNAMIC_GRAPH_READER_HPP_
+#define NETWORKIT_IO_DYNAMIC_GRAPH_READER_HPP_
+
+#include <networkit/dynamics/GraphEventProxy.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class DynamicGraphReader {
+
+public:
+    /**
+     * @param[in] path path to dynamic graph file
+     * @param[in] Gproxy graph event proxy receives the events from the file
+     */
+    virtual void read(std::string path, GraphEventProxy &Gproxy) = 0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_DYNAMIC_GRAPH_READER_HPP_