@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,71 @@
+
+#ifndef NETWORKIT_GRAPH_DFS_HPP_
+#define NETWORKIT_GRAPH_DFS_HPP_
+
+#include <stack>
+#include <vector>
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+namespace Traversal {
+
+/**
+ * Iterate over nodes in depth-first search order starting from the given source node.
+ *
+ * @param G The input graph.
+ * @param source The source node.
+ * @param handle Takes a node as input parameter.
+ */
+template <typename L>
+void DFSfrom(const Graph &G, node source, L handle) {
+    std::vector<bool> marked(G.upperNodeIdBound());
+    std::stack<node> s;
+    s.push(source); // enqueue root
+    marked[source] = true;
+    do {
+        const auto u = s.top();
+        s.pop();
+        // apply function
+        handle(u);
+        G.forNeighborsOf(u, [&](node v) {
+            if (!marked[v]) {
+                s.push(v);
+                marked[v] = true;
+            }
+        });
+    } while (!s.empty());
+}
+
+/**
+ * Iterate over edges in depth-first search order starting from the given source node.
+ *
+ * @param G The input graph.
+ * @param source The source node.
+ * @param handle Takes a node as input parameter.
+ */
+template <typename L>
+void DFSEdgesFrom(const Graph &G, node source, L handle) {
+    std::vector<bool> marked(G.upperNodeIdBound());
+    std::stack<node> s;
+    s.push(source); // enqueue root
+    marked[source] = true;
+    do {
+        const auto u = s.top();
+        s.pop();
+        // apply function
+        G.forNeighborsOf(u, [&](node, node v, edgeweight w, edgeid eid) {
+            if (!marked[v]) {
+                handle(u, v, w, eid);
+                s.push(v);
+                marked[v] = true;
+            }
+        });
+    } while (!s.empty());
+}
+
+} // namespace Traversal
+
+} // namespace NetworKit
+#endif // NETWORKIT_GRAPH_DFS_HPP_

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

@@ -0,0 +1,83 @@
+
+#ifndef NETWORKIT_GRAPH_DIJKSTRA_HPP_
+#define NETWORKIT_GRAPH_DIJKSTRA_HPP_
+
+#include <limits>
+#include <vector>
+
+#include <networkit/graph/Graph.hpp>
+
+#include <tlx/container/d_ary_addressable_int_heap.hpp>
+
+namespace NetworKit {
+
+namespace Traversal {
+
+/**
+ * Calls the given Dijkstra handle with distance parameter
+ */
+template <class F>
+auto callDijkstraHandle(F &f, node u, edgeweight dist) -> decltype(f(u, dist)) {
+    return f(u, dist);
+}
+
+/**
+ * Calls the given Dijkstra handle without distance parameter
+ */
+template <class F>
+auto callDijkstraHandle(F &f, node u, edgeweight) -> decltype(f(u)) {
+    return f(u);
+}
+
+/**
+ * Iterate over nodes with Dijkstra starting from the nodes within the given range.
+ *
+ * @param G The input graph.
+ * @param first The first element of the range.
+ * @param last The end of the range.
+ * @param handle Takes a node and its distance from the nodes in the range as input parameters.
+ */
+template <class InputIt, typename Handle>
+void DijkstraFrom(const Graph &G, InputIt first, InputIt last, Handle handle) {
+    std::vector<edgeweight> distance(G.upperNodeIdBound(), std::numeric_limits<edgeweight>::max());
+    const auto compareDistance = [&distance](node u, node v) noexcept -> bool {
+        return distance[u] < distance[v];
+    };
+
+    tlx::d_ary_addressable_int_heap<node, 2, decltype(compareDistance)> heap{compareDistance};
+
+    std::for_each(first, last, [&heap, &distance](const node u) {
+        heap.push(u);
+        distance[u] = 0;
+    });
+
+    while (!heap.empty()) {
+        const auto u = heap.extract_top();
+        callDijkstraHandle(handle, u, distance[u]);
+        G.forNeighborsOf(u, [&](const node v, const edgeweight w) {
+            if (distance[v] > distance[u] + w) {
+                distance[v] = distance[u] + w;
+                heap.update(v);
+            }
+        });
+    }
+}
+
+/**
+ * Iterate over nodes with Dijkstra starting from the nodes within the given range.
+ *
+ * @param G The input graph.
+ * @param u The source node.
+ * @param lambda Takes a node and its distance from `u` as input parameters.
+ */
+template <typename Lambda>
+void DijkstraFrom(const Graph &G, node u, Lambda lambda) {
+    std::vector<node> vec({u});
+    DijkstraFrom(G, vec.begin(), vec.end(), lambda);
+}
+
+} // namespace Traversal
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_GRAPH_DIJKSTRA_HPP_

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

@@ -0,0 +1,171 @@
+/*
+ * EdgeIterators.hpp
+ *
+ *  Created on: 16.09.2024
+ */
+
+#ifndef NETWORKIT_GRAPH_EDGE_ITERATORS_HPP_
+#define NETWORKIT_GRAPH_EDGE_ITERATORS_HPP_
+
+#include <networkit/Globals.hpp>
+#include <networkit/graph/NodeIterators.hpp>
+
+namespace NetworKit {
+
+template <typename GraphType>
+class EdgeIteratorBase {
+
+protected:
+    const GraphType *G;
+    NodeIteratorBase<GraphType> nodeIter;
+    index i{none};
+
+public:
+    EdgeIteratorBase(const GraphType *G, NodeIteratorBase<GraphType> nodeIter)
+        : G(G), nodeIter(nodeIter), i(index{0}) {
+        if (nodeIter != G->nodeRange().end() && !G->degree(*nodeIter)) {
+            nextEdge();
+        }
+    }
+
+    /**
+     * @brief WARNING: This constructor is required for Python and should not be used as the
+     * iterator is not initialized.
+     */
+    EdgeIteratorBase() : G(nullptr) {}
+
+    virtual ~EdgeIteratorBase() = default;
+
+    // A valid edge might be defined differently for different graph types
+    bool validEdge() const noexcept;
+
+    void nextEdge() {
+        do {
+            if (++i >= G->degree(*nodeIter)) {
+                i = 0;
+                do {
+                    assert(nodeIter != G->nodeRange().end());
+                    ++nodeIter;
+                    if (nodeIter == G->nodeRange().end()) {
+                        return;
+                    }
+                } while (!G->degree(*nodeIter));
+            }
+        } while (!validEdge());
+    }
+
+    void prevEdge() {
+        do {
+            if (!i) {
+                do {
+                    assert(nodeIter != G->nodeRange().begin());
+                    --nodeIter;
+                } while (!G->degree(*nodeIter));
+
+                i = G->degree(*nodeIter);
+            }
+            --i;
+        } while (!validEdge());
+    }
+
+    bool operator==(const EdgeIteratorBase &rhs) const noexcept {
+        return nodeIter == rhs.nodeIter && i == rhs.i;
+    }
+
+    bool operator!=(const EdgeIteratorBase &rhs) const noexcept { return !(*this == rhs); }
+};
+
+/**
+ * Class to iterate over the edges of the given graph type. If the graph is undirected, operator*()
+ * returns the edges (u, v) s.t. u <= v.
+ */
+template <typename GraphType, typename EdgeType>
+class EdgeTypeIterator : public EdgeIteratorBase<GraphType> {
+
+public:
+    // The value type of the edges (i.e. a pair). Returned by operator*().
+    using value_type = EdgeType;
+
+    // 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 = EdgeTypeIterator;
+
+    EdgeTypeIterator(const GraphType *G, NodeIteratorBase<GraphType> nodeIter)
+        : EdgeIteratorBase<GraphType>(G, nodeIter) {}
+
+    EdgeTypeIterator() : EdgeIteratorBase<GraphType>() {}
+
+    bool operator==(const EdgeTypeIterator &rhs) const noexcept {
+        return this->EdgeIteratorBase<GraphType>::operator==(
+            static_cast<EdgeIteratorBase<GraphType>>(rhs));
+    }
+
+    bool operator!=(const EdgeTypeIterator &rhs) const noexcept { return !(*this == rhs); }
+
+    // The returned edge depends on both the type of edge and graph
+    EdgeType operator*() const noexcept;
+
+    EdgeTypeIterator &operator++() {
+        EdgeIteratorBase<GraphType>::nextEdge();
+        return *this;
+    }
+
+    EdgeTypeIterator operator++(int) {
+        const auto tmp = *this;
+        ++(*this);
+        return tmp;
+    }
+
+    EdgeTypeIterator operator--() {
+        EdgeIteratorBase<GraphType>::prevEdge();
+        return *this;
+    }
+
+    EdgeTypeIterator operator--(int) {
+        const auto tmp = *this;
+        --(*this);
+        return tmp;
+    }
+};
+
+/**
+ * Wrapper class to iterate over a range of the edges.
+ */
+template <typename GraphType, typename EdgeType>
+class EdgeTypeRange {
+
+    const GraphType *G;
+
+public:
+    EdgeTypeRange(const GraphType &G) : G(&G) {}
+
+    EdgeTypeRange() : G(nullptr){};
+
+    ~EdgeTypeRange() = default;
+
+    EdgeTypeIterator<GraphType, EdgeType> begin() const {
+        assert(G);
+        return EdgeTypeIterator<GraphType, EdgeType>(G, G->nodeRange().begin());
+    }
+
+    EdgeTypeIterator<GraphType, EdgeType> end() const {
+        assert(G);
+        return EdgeTypeIterator<GraphType, EdgeType>(G, G->nodeRange().end());
+    }
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_GRAPH_EDGE_ITERATORS_HPP_