@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/planarity/LeftRightPlanarityCheck.hpp

@@ -0,0 +1,113 @@
+/*  LeftRightPlanarityCheck.hpp
+ *
+ *	Created on: 03.01.2025
+ *  Authors: Andreas Scharf (andreas.b.scharf@gmail.com)
+ *
+ */
+
+#ifndef NETWORKIT_PLANARITY_LEFT_RIGHT_PLANARITY_CHECK_HPP_
+#define NETWORKIT_PLANARITY_LEFT_RIGHT_PLANARITY_CHECK_HPP_
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+class LeftRightPlanarityCheck final : public Algorithm {
+
+public:
+    /**
+     * Implements the left-right planarity test as described in
+     * [citation](https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=7963e9feffe1c9362eb1a69010a5139d1da3661e).
+     * This algorithm determines whether a graph is planar, i.e., whether it can be drawn on a plane
+     * without any edges crossing. For an overview of planar graphs, refer to:
+     * https://en.wikipedia.org/wiki/Planar_graph
+     *
+     * The algorithm achieves (almost) linear runtime complexity. The only non-linear component
+     * arises from sorting the nodes of the depth-first search tree.
+     *
+     * @param G The input graph to test for planarity. The graph should be undirected.
+     * @throws std::runtime_error if graph is not an undirected graph
+     */
+    LeftRightPlanarityCheck(const Graph &G) : graph(&G) {
+        if (G.isDirected()) {
+            throw std::runtime_error("The graph is not an undirected graph.");
+        }
+        dfsGraph = GraphW(graph->numberOfNodes(), false, true, false);
+    }
+
+    /**
+     * Executes the left-right planarity test on the input graph.
+     * This method performs all necessary computations to determine
+     * whether the graph is planar and prepares the result for retrieval
+     * via the `isPlanar()` method.
+     */
+    void run() override;
+
+    /**
+     * Returns whether the input graph is planar.
+     * The result is only valid after the `run()` method has been called.
+     *
+     * @return True if the graph is planar, false otherwise.
+     * @throws std::runtime_error if called before `run()` has been executed.
+     */
+    bool isPlanar() const {
+        assureFinished();
+        return isGraphPlanar;
+    }
+
+private:
+    static const Edge noneEdge;
+    static constexpr count noneHeight{std::numeric_limits<count>::max()};
+
+    struct Interval {
+        Edge low{noneEdge};
+        Edge high{noneEdge};
+
+        Interval() : low{noneEdge}, high{noneEdge} {};
+        Interval(const Edge &low, const Edge &high) : low(low), high(high) {}
+        bool isEmpty() const { return low == noneEdge && high == noneEdge; }
+
+        friend bool operator==(const Interval &lhs, const Interval &rhs) {
+            return lhs.low == rhs.low && lhs.high == rhs.high;
+        }
+    };
+
+    struct ConflictPair {
+        Interval left{};
+        Interval right{};
+
+        ConflictPair() = default;
+        ConflictPair(const Interval &left, const Interval &right) : left(left), right(right) {}
+
+        void swap() { std::swap(left, right); }
+
+        friend bool operator==(const ConflictPair &lhs, const ConflictPair &rhs) {
+            return lhs.left == rhs.left && lhs.right == rhs.right;
+        }
+    };
+    const ConflictPair NoneConflictPair{Interval(), Interval()};
+
+    const Graph *graph;
+    bool isGraphPlanar{};
+    void dfsOrientation(node startNode);
+    bool dfsTesting(node startNode);
+    bool applyConstraints(const Edge &edge, const Edge &parentEdge);
+    void removeBackEdges(const Edge &edge);
+    void sortAdjacencyListByNestingDepth();
+    bool conflicting(const Interval &interval, const Edge &edge);
+    count getLowestLowPoint(const ConflictPair &conflictPair);
+    std::vector<count> heights;
+    std::unordered_map<Edge, count> lowestPoint;
+    std::unordered_map<Edge, count> secondLowestPoint;
+    std::unordered_map<Edge, Edge> ref;
+    std::vector<node> roots;
+    std::unordered_map<Edge, Edge> lowestPointEdge;
+    std::unordered_map<Edge, count> nestingDepth;
+    std::unordered_map<index, Edge> parentEdges;
+    std::stack<ConflictPair> stack;
+    std::unordered_map<Edge, ConflictPair> stackBottom;
+    GraphW dfsGraph;
+};
+} // namespace NetworKit
+#endif // NETWORKIT_PLANARITY_LEFT_RIGHT_PLANARITY_CHECK_HPP_

package/vendor/include/networkit/randomization/Curveball.hpp

@@ -0,0 +1,49 @@
+/*
+ * Curveball.hpp
+ *
+ *  Created on: 26.05.2018
+ *      Author:  Hung Tran <htran@ae.cs.uni-frankfurt.de>, Manuel Penschuck <networkit@manuel.jetzt>
+ */
+
+#ifndef NETWORKIT_RANDOMIZATION_CURVEBALL_HPP_
+#define NETWORKIT_RANDOMIZATION_CURVEBALL_HPP_
+
+#include <memory>
+#include <utility>
+
+#include <networkit/Globals.hpp>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+// pImpl
+namespace CurveballDetails {
+class CurveballIM;
+}
+
+class Curveball final : public Algorithm {
+public:
+    explicit Curveball(const Graph &G);
+
+    ~Curveball() override;
+
+    void run() final {
+        throw std::runtime_error("run() is not supported by this algorithm; use run(trades)");
+    };
+
+    /* The algorithm is not parallel. */
+    void run(const std::vector<std::pair<node, node>> &trades);
+
+    GraphW getGraph(bool parallel = false);
+
+    count getNumberOfAffectedEdges() const;
+
+private:
+    std::unique_ptr<CurveballDetails::CurveballIM> impl;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_RANDOMIZATION_CURVEBALL_HPP_

package/vendor/include/networkit/randomization/CurveballGlobalTradeGenerator.hpp

@@ -0,0 +1,39 @@
+/*
+ * CurveballGlobalTradeGenerator.hpp
+ *
+ *  Created on: Jul 11, 2017
+ *      Author: Hung Tran <htran@ae.cs.uni-frankfurt.de>
+ */
+
+#ifndef NETWORKIT_RANDOMIZATION_CURVEBALL_GLOBAL_TRADE_GENERATOR_HPP_
+#define NETWORKIT_RANDOMIZATION_CURVEBALL_GLOBAL_TRADE_GENERATOR_HPP_
+
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+#include <networkit/Globals.hpp>
+
+namespace NetworKit {
+
+class CurveballGlobalTradeGenerator final {
+public:
+    using value_type = std::vector<std::pair<node, node>>;
+
+private:
+    const node numNodes;
+    const count numGlobalTrades;
+
+public:
+    CurveballGlobalTradeGenerator(count run_length, node num_nodes)
+        : numNodes(num_nodes), numGlobalTrades(run_length) {
+        if (num_nodes <= 1)
+            throw std::runtime_error("At least two nodes are required.");
+    }
+
+    value_type generate() const;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_RANDOMIZATION_CURVEBALL_GLOBAL_TRADE_GENERATOR_HPP_

package/vendor/include/networkit/randomization/CurveballUniformTradeGenerator.hpp

@@ -0,0 +1,39 @@
+/*
+ * CurveballUniformTradeGenerator.hpp
+ *
+ *  Created on: Jul 11, 2017
+ *      Author: Hung Tran <htran@ae.cs.uni-frankfurt.de>
+ */
+
+#ifndef NETWORKIT_RANDOMIZATION_CURVEBALL_UNIFORM_TRADE_GENERATOR_HPP_
+#define NETWORKIT_RANDOMIZATION_CURVEBALL_UNIFORM_TRADE_GENERATOR_HPP_
+
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+#include <networkit/Globals.hpp>
+
+namespace NetworKit {
+
+class CurveballUniformTradeGenerator final {
+public:
+    using value_type = std::vector<std::pair<node, node>>;
+
+private:
+    const count numTrades;
+    const node numNodes;
+
+public:
+    CurveballUniformTradeGenerator(count trade_num, node num_nodes)
+        : numTrades(trade_num), numNodes(num_nodes) {
+        if (num_nodes <= 1)
+            throw std::runtime_error("At least two nodes are required.");
+    }
+
+    value_type generate() const;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_RANDOMIZATION_CURVEBALL_UNIFORM_TRADE_GENERATOR_HPP_

package/vendor/include/networkit/randomization/DegreePreservingShuffle.hpp

@@ -0,0 +1,82 @@
+/*
+ * DegreePreservingShuffle.hpp
+ *
+ *  Created on: 21.08.2018
+ *      Author: Manuel Penschuck <networkit@manuel.jetzt>
+ */
+
+#ifndef NETWORKIT_RANDOMIZATION_DEGREE_PRESERVING_SHUFFLE_HPP_
+#define NETWORKIT_RANDOMIZATION_DEGREE_PRESERVING_SHUFFLE_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * 	Implementation of the preprocessing step proposed in
+ *  "Smaller Universes for Uniform Sampling of 0,1-matrices with fixed row and column sums"
+ *  by Annabell Berger, Corrie Jacobien Carstens [https://arxiv.org/abs/1803.02624]
+ *
+ *  The algorithms randomizes a graph without changing its topology simply
+ *  by renaming nodes. For any degree d (in case of an directed graph it's a degree pair)
+ *  consider the set X_d of node ids which have this degree. Then shuffle the ids in X_d.
+ *
+ *  Hence the algorithm satisfies: For all x in Ginput:
+ *   i)  Ginput.degreeIn(x) = Goutput.degreeIn(x)
+ *   ii) Ginput.degreeOut(x) = Goutput.degreeOut(x)
+ *
+ *  The authors argue that applying this preprocessing step before executing (Global)Curveball
+ *  leads to a faster mixing time.
+ *
+ *  @node If you want to use it as a preprocessing step to GlobalCurveball, it's more
+ *  efficient to set degreePreservingShufflePreprocessing in GlobalCurveball's constructor.
+ */
+class DegreePreservingShuffle final : public Algorithm {
+public:
+    DegreePreservingShuffle() = delete;
+
+    /**
+     * Instantiate a DegreePreservingShuffle object
+     *
+     * @param G Input graph that will be shuffled
+     */
+    explicit DegreePreservingShuffle(const Graph &G);
+
+    ~DegreePreservingShuffle() override;
+
+    /**
+     * Execute trades as configured in the constructor. The algorithm is parallel.
+     * @warning This function has to be called exactly once before invoking getGraph()
+     */
+    void run() final;
+
+    /**
+     * Returns a shuffled copy of the input graph.
+     * @warning Invoke run() before calling this function.
+     */
+    GraphW getGraph() const;
+
+    /**
+     * Returns a reference to the permutation used for shuffling,
+     * with permutation[old] = new.
+     *
+     * @warning Invoke run() before calling this function.
+     */
+    const std::vector<node> &getPermutation() const noexcept { return permutation; }
+
+    static GraphW shuffleGraph(const Graph &input) {
+        DegreePreservingShuffle algo(input);
+        algo.run();
+        return algo.getGraph();
+    }
+
+private:
+    const Graph *G;
+    std::vector<node> permutation;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_RANDOMIZATION_DEGREE_PRESERVING_SHUFFLE_HPP_

package/vendor/include/networkit/randomization/EdgeSwitching.hpp

@@ -0,0 +1,157 @@
+/*
+ * EdgeSwitching.hpp
+ *
+ *  Created on: 19.10.2019
+ *      Author:  Manuel Penschuck <networkit@manuel.jetzt>
+ */
+
+#ifndef NETWORKIT_RANDOMIZATION_EDGE_SWITCHING_HPP_
+#define NETWORKIT_RANDOMIZATION_EDGE_SWITCHING_HPP_
+
+#include <random>
+#include <string>
+#include <utility>
+
+#include <networkit/Globals.hpp>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * EdgeSwitching and EdgeSwitchingInPlace implement the same algorithm -- while the former copies
+ * the input graph provided and is more versatile, the in-place implementation only keeps a
+ * reference to the input graph.
+ *
+ * The Edge Switching Markov Chain ["The markov chain simulation method for generating connected
+ * power law random graphs", Mihail and Zegura] perturbates simple directed or undirected graphs
+ * while preserving their degrees. In each step, two edges are selected uniformly at random, and
+ * their endpoints exchanged. Swaps that introduce multi-edges or self-loops are rejected WITHOUT
+ * replacement -- this is necessary to allow uniform sampling [see "Switching edges to randomize
+ * networks: what goes wrong and how to fix it", Carstens and Horadam]. The number of successful
+ * swaps can be queried using getNumberOfAffectedEdges()/2.
+ *
+ * @note In general, simple edge switching does not yield a uniform distribution on simple DIRECTED
+ * graphs because the orientation of directed triangles cannot be changed. Using
+ * DegreePreservingShuffle as a preprocessing step overcomes this limitation. The preprocessing can
+ * also jump-start the perturbation process, yielding to potentially faster mixing.
+ *
+ * It's recommended to implement the preprocessing step in the calling code or to use copying
+ * EdgeSwitching implementation.
+ */
+class EdgeSwitchingInPlace : public Algorithm {
+public:
+    /**
+     * Constructs an EdgeSwitch algorithm that will change the input graph IN-PLACE.
+     * @warning For directed graphs preprocessing with DegreePreservingShuffle is necessary. Either
+     * do it manually, or use another constructor.
+     */
+    EdgeSwitchingInPlace(GraphW &G, double numberOfSwitchesPerEdge = 10.0) : graph(G) {
+        setNumberOfSwitchesPerEdge(numberOfSwitchesPerEdge);
+    }
+
+    ~EdgeSwitchingInPlace() override = default;
+
+    /**
+     * Attempts to carry out numberOfSwitchesPerEdge * numberOfEdges() edge swaps (i.e., rejected
+     * swaps are counted as well, see Algorithm's description why)
+     * @note This function can be called several times. The graph's topology may not be changed
+     * externally between two invocations.
+     */
+    void run() override;
+
+    /// Return a reference to the perturbed graph
+    GraphW &getGraph() const { return graph; }
+
+    /**
+     * Returns twice the total number of non-rejected swaps carried out during calls to run().
+     * It hence has the same semantics as Curveball::getNumberOfAffectedEdges().
+     * @note If run() is called multiple time, the sum over all invocations is returned.
+     */
+    count getNumberOfAffectedEdges() const noexcept { return 2 * numberOfSwapsPerformed; }
+
+    /// Return (average) number of switches per edge that will be executed on next run
+    double getNumberOfSwitchesPerEdge() const noexcept { return numberOfSwitchesPerEdge; }
+
+    /// Modify (average) number of switches per edge that will be executed on next run
+    void setNumberOfSwitchesPerEdge(double x);
+
+protected:
+    GraphW &graph;
+    std::discrete_distribution<node>
+        degreeDistribution; ///< Return node x with probability proportional to degree(x)
+
+    double numberOfSwitchesPerEdge;
+    count numberOfSwapsPerformed{0};
+};
+
+/**
+ * EdgeSwitching and EdgeSwitchingInPlace implement the same algorithm -- while the former copies
+ * the input graph provided and is more versatile, the in-place implementation only keeps a
+ * reference to the input graph.
+ *
+ * The Edge Switching Markov Chain ["The markov chain simulation method for generating connected
+ * power law random graphs", Mihail and Zegura] perturbates simple directed or undirected graphs
+ * while preserving their degrees. In each step, two edges are selected uniformly at random, and
+ * their endpoints exchanged. Swaps that introduce multi-edges or self-loops are rejected WITHOUT
+ * replacement -- this is necessary to allow uniform sampling [see "Switching edges to randomize
+ * networks: what goes wrong and how to fix it", Carstens and Horadam]. The number of successful
+ * swaps can be queried using getNumberOfAffectedEdges()/2.
+ *
+ * @note In general, simple edge switching does not yield a uniform distribution on simple DIRECTED
+ * graphs because the orientation of directed triangles cannot be changed. Using
+ * DegreePreservingShuffle as a preprocessing step overcomes this limitation. The preprocessing can
+ * also jump-start the perturbation process, yielding to potentially faster mixing.
+ *
+ * It's recommended to implement the preprocessing step in the calling code or to use copying
+ * EdgeSwitching implementation.
+ */
+class EdgeSwitching : public Algorithm {
+public:
+    /// Constructs an EdgeSwitch algorithm that contains a COPY of the input graph.
+    explicit EdgeSwitching(const GraphW &G, double numberOfSwitchesPerEdge = 10.0,
+                           bool degreePreservingShufflePreprocessing = true);
+
+    ~EdgeSwitching() override = default;
+
+    /**
+     * Attempts to carry out numberOfSwitchesPerEdge * numberOfEdges() edge swaps (i.e., rejected
+     * swaps are counted as well, see Algorithm's description why)
+     */
+    void run() override { inPlaceAlgorithm.run(); }
+
+    /// Return a reference to the perturbed graph
+    const GraphW &getGraph() const { return ownedGraph; }
+
+    /**
+     * Move graph owned by the algorithm out.
+     * @warning Do not call run() after calling moveGraph()
+     */
+    GraphW moveGraph() { return std::move(ownedGraph); }
+
+    /**
+     * Returns twice the total number of non-rejected swaps carried out during calls to run().
+     * It hence has the same semantics as Curveball::getNumberOfAffectedEdges().
+     * @note If run() is called multiple time, the sum over all invocations is returned.
+     */
+    count getNumberOfAffectedEdges() const noexcept {
+        return inPlaceAlgorithm.getNumberOfAffectedEdges();
+    }
+
+    /// Return (average) number of switches per edge that will be executed on next run
+    double getNumberOfSwitchesPerEdge() const noexcept {
+        return inPlaceAlgorithm.getNumberOfSwitchesPerEdge();
+    }
+
+    /// Modify (average) number of switches per edge that will be executed on next run
+    void setNumberOfSwitchesPerEdge(double x) { inPlaceAlgorithm.setNumberOfSwitchesPerEdge(x); }
+
+private:
+    GraphW ownedGraph;
+    EdgeSwitchingInPlace inPlaceAlgorithm;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_RANDOMIZATION_EDGE_SWITCHING_HPP_

package/vendor/include/networkit/randomization/GlobalCurveball.hpp

@@ -0,0 +1,69 @@
+/*
+ * GlobalCurveball.hpp
+ *
+ *  Created on: 26.05.2018
+ *      Author: Manuel Penschuck <networkit@manuel.jetzt>
+ */
+
+#ifndef NETWORKIT_RANDOMIZATION_GLOBAL_CURVEBALL_HPP_
+#define NETWORKIT_RANDOMIZATION_GLOBAL_CURVEBALL_HPP_
+
+#include <memory>
+#include <utility>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+// pImpl
+namespace CurveballDetails {
+class GlobalCurveballImpl;
+}
+
+class GlobalCurveball final : public Algorithm {
+public:
+    /**
+     * Instantiate a GlobalCurveball object
+     *
+     * @param G                        Undirected and unweighted graph to be randomized
+     * @param number_of_global_trades  Number of global trades to be executed (each edge
+     *                                 is considered exactly twice per global traded)
+     * @param allowSelfLoops           May only be set if graph is directed.
+     * @param degreePreservingShufflePreprocessing Execute DegreePreservingShuffle
+     *                                 (see Algorithm for description) as a preprocessing
+     *                                 step. This is more efficient than calling the algorithm
+     *                                 explicitly.
+     *
+     * @note Self loops can only be realized for directed graphs.
+     * @warning If self loops are forbidden, degreePreservingShuffle is necessary for
+     * directed graphs, since otherwise some topologies cannot be realized (i.e., only
+     * preprocessing allows for uniform samples).
+     */
+    explicit GlobalCurveball(const Graph &G, count number_of_global_trades = 20,
+                             bool allowSelfLoops = false,
+                             bool degreePreservingShufflePreprocessing = true);
+
+    ~GlobalCurveball() override;
+
+    /**
+     * Execute trades as configured in the constructor. The algorithm is not parallel.
+     * @warning This function has to be called exactly one before invoking getGraph()
+     */
+    void run() final;
+
+    /**
+     * Returns a new graph instance with the same degree sequence as the input
+     * graph, but with randomized neighbourhoods.
+     */
+    GraphW getGraph();
+
+private:
+    std::unique_ptr<CurveballDetails::GlobalCurveballImpl> impl;
+    unsigned numGlobalTrades;
+    bool degreePreservingShuffle;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_RANDOMIZATION_GLOBAL_CURVEBALL_HPP_