@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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

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

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

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