@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,50 @@
+/*
+ * KruskalMSF.hpp
+ *
+ *  Created on: 03.09.2015
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_GRAPH_KRUSKAL_MSF_HPP_
+#define NETWORKIT_GRAPH_KRUSKAL_MSF_HPP_
+
+#include <networkit/Globals.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/SpanningForest.hpp>
+
+namespace NetworKit {
+
+/**
+ * Creates a minimum spanning tree for each connected component.
+ * @ingroup graph
+ */
+class KruskalMSF final : public SpanningForest {
+public:
+    KruskalMSF(const Graph &G);
+
+    /**
+     * Computes for each component a minimum weight spanning tree
+     * (or simply a spanning tree in unweighted graphs).
+     * Uses Kruskal's algorithm.
+     * Time complexity: sort(n) + n * inverse Ackermann(n, m).
+     */
+    void run() override;
+
+    /**
+     * @return Total edge-weight of the spanning forest.
+     * Number of edges in forest if input graph is unweighted.
+     */
+    edgeweight getTotalWeight() const {
+        assureFinished();
+        if (G->isWeighted())
+            return totalWeight;
+        else
+            return static_cast<edgeweight>(forest.numberOfEdges());
+    }
+
+private:
+    edgeweight totalWeight = 0.0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GRAPH_KRUSKAL_MSF_HPP_

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

@@ -0,0 +1,163 @@
+/*
+ * NeighborIterators.hpp
+ *
+ *  Created on: 16.09.2024
+ */
+
+#ifndef NETWORKIT_GRAPH_NEIGHBOR_ITERATORS_HPP_
+#define NETWORKIT_GRAPH_NEIGHBOR_ITERATORS_HPP_
+
+namespace NetworKit {
+
+/**
+ * Class to iterate over the in/out neighbors of a node.
+ */
+template <typename containerType>
+class NeighborIteratorBase {
+
+    typename containerType::const_iterator elementIter;
+
+public:
+    // The value type of the neighbors (i.e. nodes). Returned by
+    // operator*().
+    using value_type = typename containerType::value_type;
+
+    // Reference to the value_type, required by STL.
+    using reference = value_type &;
+
+    // Pointer to the value_type, required by STL.
+    using pointer = value_type *;
+
+    // STL iterator category.
+    using iterator_category = std::forward_iterator_tag;
+
+    // Signed integer type of the result of subtracting two pointers,
+    // required by STL.
+    using difference_type = ptrdiff_t;
+
+    // Own type.
+    using self = NeighborIteratorBase;
+
+    NeighborIteratorBase(typename containerType::const_iterator elementIter)
+        : elementIter(elementIter) {}
+
+    /**
+     * @brief WARNING: This contructor is required for Python and should not be used as the
+     * iterator is not initialized.
+     */
+    NeighborIteratorBase() {}
+
+    NeighborIteratorBase &operator++() {
+        ++elementIter;
+        return *this;
+    }
+
+    NeighborIteratorBase operator++(int) {
+        const auto tmp = *this;
+        ++elementIter;
+        return tmp;
+    }
+
+    NeighborIteratorBase operator--() {
+        const auto tmp = *this;
+        --elementIter;
+        return tmp;
+    }
+
+    NeighborIteratorBase operator--(int) {
+        --elementIter;
+        return *this;
+    }
+
+    bool operator==(const NeighborIteratorBase &rhs) const {
+        return elementIter == rhs.elementIter;
+    }
+
+    bool operator!=(const NeighborIteratorBase &rhs) const {
+        return !(elementIter == rhs.elementIter);
+    }
+
+    value_type operator*() const { return *elementIter; }
+};
+
+/**
+ * Class to iterate over the in/out neighbors of a containerType, including the
+ * weights given by weightContainerType.
+ */
+template <typename containerType, typename weightContainerType>
+class NeighborWeightIteratorBase {
+
+    typename containerType::const_iterator elementIter;
+    typename weightContainerType::const_iterator weightIter;
+
+public:
+    // The value type of the neighbors (i.e. nodes). Returned by
+    // operator*().
+    using value_type =
+        std::pair<typename containerType::value_type, typename weightContainerType::value_type>;
+
+    // Reference to the value_type, required by STL.
+    using reference = value_type &;
+
+    // Pointer to the value_type, required by STL.
+    using pointer = value_type *;
+
+    // STL iterator category.
+    using iterator_category = std::forward_iterator_tag;
+
+    // Signed integer type of the result of subtracting two pointers,
+    // required by STL.
+    using difference_type = ptrdiff_t;
+
+    // Own type.
+    using self = NeighborWeightIteratorBase;
+
+    NeighborWeightIteratorBase(typename containerType::const_iterator elementIter,
+                               typename weightContainerType::const_iterator weightIter)
+        : elementIter(elementIter), weightIter(weightIter) {}
+
+    /**
+     * @brief WARNING: This contructor is required for Python and should not be used as the
+     * iterator is not initialized.
+     */
+    NeighborWeightIteratorBase() {}
+
+    NeighborWeightIteratorBase &operator++() {
+        ++elementIter;
+        ++weightIter;
+        return *this;
+    }
+
+    NeighborWeightIteratorBase operator++(int) {
+        const auto tmp = *this;
+        ++(*this);
+        return tmp;
+    }
+
+    NeighborWeightIteratorBase operator--() {
+        --elementIter;
+        --weightIter;
+        return *this;
+    }
+
+    NeighborWeightIteratorBase operator--(int) {
+        const auto tmp = *this;
+        --(*this);
+        return tmp;
+    }
+
+    bool operator==(const NeighborWeightIteratorBase &rhs) const {
+        return elementIter == rhs.elementIter && weightIter == rhs.weightIter;
+    }
+
+    bool operator!=(const NeighborWeightIteratorBase &rhs) const { return !(*this == rhs); }
+
+    std::pair<typename containerType::value_type, typename weightContainerType::value_type>
+    operator*() const {
+        return std::make_pair(*elementIter, *weightIter);
+    }
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_GRAPH_NEIGHBOR_ITERATORS_HPP_

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

@@ -0,0 +1,127 @@
+/*
+ * NodeIterators.hpp
+ *
+ *  Created on: 16.09.2024
+ */
+
+#ifndef NETWORKIT_GRAPH_NODE_ITERATORS_HPP_
+#define NETWORKIT_GRAPH_NODE_ITERATORS_HPP_
+
+#include <cassert>
+#include <iterator>
+
+#include <networkit/Globals.hpp>
+
+namespace NetworKit {
+
+/**
+ * Class to iterate over the nodes of a graph.
+ */
+template <typename GraphType>
+class NodeIteratorBase {
+
+    const GraphType *G;
+    node u{none};
+
+public:
+    // The value type of the nodes (i.e. nodes). Returned by
+    // operator*().
+    using value_type = node;
+
+    // Reference to the value_type, required by STL.
+    using reference = value_type &;
+
+    // Pointer to the value_type, required by STL.
+    using pointer = value_type *;
+
+    // STL iterator category.
+    using iterator_category = std::forward_iterator_tag;
+
+    // Signed integer type of the result of subtracting two pointers,
+    // required by STL.
+    using difference_type = ptrdiff_t;
+
+    // Own type.
+    using self = NodeIteratorBase;
+
+    NodeIteratorBase(const GraphType *G, node u) : G(G), u(u) {
+        if (!G->hasNode(u) && u < G->upperNodeIdBound()) {
+            ++(*this);
+        }
+    }
+
+    /**
+     * @brief WARNING: This constructor is required for Python and should not be used as the
+     * iterator is not initialized.
+     */
+    NodeIteratorBase() : G(nullptr) {}
+
+    ~NodeIteratorBase() = default;
+
+    NodeIteratorBase &operator++() {
+        assert(u < G->upperNodeIdBound());
+        do {
+            ++u;
+        } while (!(G->hasNode(u) || u >= G->upperNodeIdBound()));
+        return *this;
+    }
+
+    NodeIteratorBase operator++(int) {
+        const auto tmp = *this;
+        ++(*this);
+        return tmp;
+    }
+
+    NodeIteratorBase operator--() {
+        assert(u);
+        do {
+            --u;
+        } while (!G->hasNode(u));
+        return *this;
+    }
+
+    NodeIteratorBase operator--(int) {
+        const auto tmp = *this;
+        --(*this);
+        return tmp;
+    }
+
+    bool operator==(const NodeIteratorBase &rhs) const noexcept { return u == rhs.u; }
+
+    bool operator!=(const NodeIteratorBase &rhs) const noexcept { return !(*this == rhs); }
+
+    node operator*() const noexcept {
+        assert(u < G->upperNodeIdBound());
+        return u;
+    }
+};
+
+/**
+ * Wrapper class to iterate over a range of the nodes of a graph.
+ */
+template <typename GraphType>
+class NodeRangeBase {
+
+    const GraphType *G;
+
+public:
+    NodeRangeBase(const GraphType &G) : G(&G) {}
+
+    NodeRangeBase() : G(nullptr){};
+
+    ~NodeRangeBase() = default;
+
+    NodeIteratorBase<GraphType> begin() const noexcept {
+        assert(G);
+        return NodeIteratorBase(G, node{0});
+    }
+
+    NodeIteratorBase<GraphType> end() const noexcept {
+        assert(G);
+        return NodeIteratorBase(G, G->upperNodeIdBound());
+    }
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_GRAPH_NODE_ITERATORS_HPP_

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

@@ -0,0 +1,66 @@
+
+/*  PrimMST.hpp
+ *
+ *	Created on: 29.03.2025
+ *  Authors: Andreas Scharf (andreas.b.scharf@gmail.com)
+ *
+ */
+#ifndef NETWORKIT_GRAPH_PRIM_MSF_HPP_
+#define NETWORKIT_GRAPH_PRIM_MSF_HPP_
+#include <networkit/Globals.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/SpanningForest.hpp>
+
+namespace NetworKit {
+
+/**
+ * @class PrimMSF
+ * @brief Computes a Minimum Spanning Forest using Prim's algorithm.
+ *
+ * For a given undirected graph, this algorithm grows a forest by greedily
+ * adding the smallest edge between visited and unvisited nodes.
+ * If the graph is connected, the result is a Minimum Spanning Tree (MST).
+ * Otherwise, it yields a forest of MSTs for each connected component.
+ */
+class PrimMSF : public SpanningForest {
+public:
+    /**
+     * @brief Initializes the PrimMSF algorithm for a given graph.
+     *
+     * The input graph must be undirected. It may be either weighted or unweighted.
+     * In the case of an unweighted graph, each edge is treated as having unit weight.
+     *
+     * @param G The graph on which the minimum spanning forest will be computed.
+     * @throws std::runtime_error if graph is not an undirected graph
+     */
+    PrimMSF(const Graph &G) : SpanningForest(G) {
+        if (G.isDirected()) {
+            throw std::runtime_error("The graph is not an undirected graph.");
+        }
+    }
+
+    /**
+     * @brief Runs Prim's algorithm to compute the minimum spanning forest.
+     *
+     * For each connected component of the graph, constructs a minimum spanning tree
+     * and computes the total weight of the resulting forest.
+     */
+    void run() override;
+
+    /**
+     * @brief Returns the total weight of the minimum spanning forest.
+     * @return The total weight of the minimum spanning forest.
+     */
+    edgeweight getTotalWeight() const {
+        assureFinished();
+        if (G->isWeighted())
+            return totalWeight;
+        return static_cast<edgeweight>(forest.numberOfEdges());
+    }
+
+private:
+    static constexpr edgeweight infiniteWeight = std::numeric_limits<edgeweight>::max();
+    edgeweight totalWeight = 0;
+};
+} // namespace NetworKit
+#endif // NETWORKIT_GRAPH_PRIM_MSF_HPP_

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

@@ -0,0 +1,133 @@
+#ifndef NETWORKIT_GRAPH_RANDOM_MAXIMUM_SPANNING_FOREST_HPP_
+#define NETWORKIT_GRAPH_RANDOM_MAXIMUM_SPANNING_FOREST_HPP_
+
+#include <limits>
+
+#include <networkit/auxiliary/Log.hpp>
+#include <networkit/auxiliary/Random.hpp>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/GraphW.hpp>
+#include <networkit/structures/UnionFind.hpp>
+
+namespace NetworKit {
+
+/**
+ * Computes a random maximum-weight spanning forest using Kruskal's algorithm by randomizing the
+ * order of edges of the same weight.
+ */
+class RandomMaximumSpanningForest : public Algorithm {
+public:
+    /**
+     * Initialize the random maximum-weight spanning forest algorithm, uses edge weights.
+     *
+     * @param G The input graph.
+     */
+    RandomMaximumSpanningForest(const Graph &G);
+
+    /**
+     * Initialize the random 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>
+    RandomMaximumSpanningForest(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 the calculated
+     * 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 the calculated 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 the calculated maximum-weight spanning forest.
+     */
+    bool inMSF(node u, node v) const;
+
+    /**
+     * Checks if the edge with the id @a eid is part of the calculated maximum-weight spanning
+     * forest.
+     *
+     * @param eid The id of the edge to check.
+     * @return If the edge is part of the calculated maximum-weight spanning forest.
+     */
+    bool inMSF(edgeid eid) const;
+
+    /**
+     * Gets the calculated maximum-weight spanning forest as graph.
+     *
+     * @param move If the graph shall be moved out of the algorithm instance.
+     * @return The calculated maximum-weight spanning forest.
+     */
+    GraphW getMSF(bool move = false);
+
+private:
+    struct weightedEdge {
+        double attribute;
+        node u;
+        node v;
+        edgeid eid;
+        index rand;
+
+        bool operator>(const weightedEdge &other) const {
+            return (attribute > other.attribute)
+                   || (attribute == other.attribute
+                       && (rand > other.rand
+                           || (rand == other.rand
+                               && (u > other.u || (u == other.u && v > other.v)))));
+        };
+        weightedEdge(node u, node v, double attribute, edgeid eid = 0)
+            : attribute(attribute), u(u), v(v), eid(eid), rand(Aux::Random::integer()){};
+    };
+
+    const Graph &G;
+    std::vector<weightedEdge> weightedEdges;
+
+    GraphW msf;
+    std::vector<bool> msfAttribute;
+
+    bool hasWeightedEdges;
+    bool hasMSF;
+    bool hasAttribute;
+};
+
+template <typename A>
+RandomMaximumSpanningForest::RandomMaximumSpanningForest(const Graph &G,
+                                                         const std::vector<A> &attribute)
+    : G(G), hasWeightedEdges(false), hasMSF(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_RANDOM_MAXIMUM_SPANNING_FOREST_HPP_

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

@@ -0,0 +1,41 @@
+/*
+ * SpanningForest.hpp
+ *
+ *  Created on: 06.09.2015
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_GRAPH_SPANNING_FOREST_HPP_
+#define NETWORKIT_GRAPH_SPANNING_FOREST_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * Base class for spanning forest/tree algorithms.
+ */
+class SpanningForest : public Algorithm {
+protected:
+    const Graph *G;
+    GraphW forest;
+
+public:
+    SpanningForest(const Graph &G) : G(&G) {}
+
+    void run() override;
+
+    /**
+     * @return Forest computed by run method.
+     * Note: So far no explicit check if run method has been invoked before.
+     */
+    const GraphW &getForest() {
+        assureFinished();
+        return forest;
+    }
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_GRAPH_SPANNING_FOREST_HPP_

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

@@ -0,0 +1,87 @@
+/*
+ * TopologicalSort.hpp
+ *
+ *  Created on: 22.11.2021
+ *      Author: Fabian Brandt-Tumescheit
+ */
+#ifndef NETWORKIT_GRAPH_TOPOLOGICAL_SORT_HPP_
+#define NETWORKIT_GRAPH_TOPOLOGICAL_SORT_HPP_
+
+#include <optional>
+#include <unordered_map>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * Given a directed graph G, the topology sort algorithm creates one valid topology order of nodes.
+ * Undirected graphs are not accepted as input, since a topology sort is a linear ordering of
+ * vertices such that for every edge u -> v, node u comes before v in the ordering.
+ */
+class TopologicalSort final : public Algorithm {
+public:
+    /**
+     * Initialize the topological sort algorithm by passing an input graph.
+     *
+     * @param G The input graph.
+     */
+    TopologicalSort(const Graph &G);
+
+    /**
+     * Initialize the topological sort algorithm by passing an input graph and an node id map.
+     * The node id mapping must be a continuous. This can be checked by setting checkMapping to
+     * true.
+     *
+     * @param G The input graph.
+     * @param nodeIdMapping Node id mapping from non-continuous to continuous ids.
+     * @param checkMapping Check whether the given node id map is continuous.
+     */
+    TopologicalSort(const Graph &G, const std::unordered_map<node, node> &nodeIdMapping,
+                    bool checkMapping = false);
+
+    /**
+     * Execute the algorithm. The algorithm is not parallel.
+     */
+    void run() override;
+
+    /**
+     * Return the topology
+     *
+     * @return One valid topology. Order in topology is from 0 to number of nodes.
+     */
+    const std::vector<node> &getResult() const {
+        assureFinished();
+        return topology;
+    }
+
+private:
+    enum class NodeMark : unsigned char { NONE, TEMP, PERM };
+
+    const Graph &G;
+
+    std::optional<std::unordered_map<node, node>> computedNodeIdMap;
+
+    const std::unordered_map<node, node> *nodeIdMap = nullptr;
+
+    // Used to mark the status of each node, one vector per thread
+    std::vector<NodeMark> topSortMark;
+
+    // Contains information about the computed topology
+    std::vector<node> topology;
+
+    // Helper structures
+    count current;
+
+    void checkDirected();
+
+    void checkNodeIdMap();
+
+    node mapNode(node u);
+
+    // Reset algorithm data structure
+    void reset();
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_GRAPH_TOPOLOGICAL_SORT_HPP_