@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,2083 @@
+/*
+ * Graph.hpp
+ *
+ *  Created on: 01.06.2014
+ *      Author: Christian Staudt
+ *              Klara Reichard <klara.reichard@gmail.com>
+ *              Marvin Ritter <marvin.ritter@gmail.com>
+ */
+
+#ifndef NETWORKIT_GRAPH_GRAPH_HPP_
+#define NETWORKIT_GRAPH_GRAPH_HPP_
+
+#include <algorithm>
+#include <fstream>
+#include <functional>
+#include <memory>
+#include <numeric>
+#include <omp.h>
+#include <queue>
+#include <ranges>
+#include <sstream>
+#include <stack>
+#include <stdexcept>
+#include <typeindex>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <networkit/Globals.hpp>
+#include <networkit/auxiliary/ArrayTools.hpp>
+#include <networkit/auxiliary/FunctionTraits.hpp>
+#include <networkit/auxiliary/Log.hpp>
+#include <networkit/auxiliary/Random.hpp>
+#include <networkit/graph/Attributes.hpp>
+#include <networkit/graph/EdgeIterators.hpp>
+#include <networkit/graph/NeighborIterators.hpp>
+#include <networkit/graph/NodeIterators.hpp>
+
+#include <tlx/define/deprecated.hpp>
+
+#include <arrow/api.h>
+#include <arrow/compute/api.h>
+
+namespace NetworKit {
+
+struct Edge {
+    node u, v;
+
+    Edge() : u(none), v(none) {}
+
+    Edge(node _u, node _v, bool sorted = false) {
+        u = sorted ? std::min(_u, _v) : _u;
+        v = sorted ? std::max(_u, _v) : _v;
+    }
+};
+
+/**
+ * A weighted edge used for the graph constructor with
+ * initializer list syntax.
+ */
+struct WeightedEdge : Edge {
+    edgeweight weight;
+
+    // Needed by cython
+    WeightedEdge() : Edge(), weight(std::numeric_limits<edgeweight>::max()) {}
+
+    WeightedEdge(node u, node v, edgeweight w) : Edge(u, v), weight(w) {}
+};
+
+struct WeightedEdgeWithId : WeightedEdge {
+    edgeid eid;
+
+    WeightedEdgeWithId(node u, node v, edgeweight w, edgeid eid)
+        : WeightedEdge(u, v, w), eid(eid) {}
+};
+
+inline bool operator==(const Edge &e1, const Edge &e2) {
+    return e1.u == e2.u && e1.v == e2.v;
+}
+
+inline bool operator<(const WeightedEdge &e1, const WeightedEdge &e2) {
+    return e1.weight < e2.weight;
+}
+
+struct Unsafe {};
+static constexpr Unsafe unsafe{};
+} // namespace NetworKit
+
+namespace std {
+template <>
+struct hash<NetworKit::Edge> {
+    size_t operator()(const NetworKit::Edge &e) const { return hash_node(e.u) ^ hash_node(e.v); }
+
+    hash<NetworKit::node> hash_node;
+};
+} // namespace std
+
+namespace NetworKit {
+
+// forward declaration to randomization/CurveballImpl.hpp
+namespace CurveballDetails {
+class CurveballMaterialization;
+}
+
+/**
+ * @ingroup graph
+ * A graph (with optional weights) and parallel iterator methods.
+ */
+class Graph {
+
+protected:
+    // graph attributes
+    //!< current number of nodes
+    count n;
+    //!< current number of edges
+    count m;
+
+    //!< current number of self loops, edges which have the same origin and
+    //!< target
+    count storedNumberOfSelfLoops;
+
+    //!< current upper bound of node ids, z will be the id of the next node
+    node z;
+    //!< current upper bound of edge ids, will be the id of the next edge
+    edgeid omega;
+    //!< current time step
+    count t;
+
+    //!< true if the graph is weighted, false otherwise
+    bool weighted;
+    //!< true if the graph is directed, false otherwise
+    bool directed;
+    //!< true if edge ids have been assigned
+    bool edgesIndexed;
+
+    //!< true if edge removals should maintain compact edge ids
+    bool maintainCompactEdges = false;
+    //!< true if edge removals should maintain sorted edge ids
+    bool maintainSortedEdges = false;
+
+    //!< saves the ID of the most recently removed edge (if exists)
+    edgeid deletedID;
+
+    // per node data
+    //!< exists[v] is true if node v has not been removed from the graph
+    std::vector<bool> exists;
+
+    // CSR arrays for memory-efficient graph storage (zero-copy from Arrow)
+    //!< Arrow array for CSR indices (neighbor node IDs) for outgoing edges
+    std::shared_ptr<arrow::UInt64Array> outEdgesCSRIndices;
+    //!< Arrow array for CSR indptr (offsets into indices array) for outgoing edges
+    std::shared_ptr<arrow::UInt64Array> outEdgesCSRIndptr;
+    //!< Arrow array for CSR indices (neighbor node IDs) for incoming edges - only for directed
+    //!< graphs
+    std::shared_ptr<arrow::UInt64Array> inEdgesCSRIndices;
+    //!< Arrow array for CSR indptr (offsets into indices array) for incoming edges - only for
+    //!< directed graphs
+    std::shared_ptr<arrow::UInt64Array> inEdgesCSRIndptr;
+    //!< Arrow array for CSR edge weights for outgoing edges
+    std::shared_ptr<arrow::DoubleArray> outEdgesCSRWeights;
+    //!< Arrow array for CSR edge weights for incoming edges - only for directed graphs
+    std::shared_ptr<arrow::DoubleArray> inEdgesCSRWeights;
+    //!< flag to indicate if CSR arrays are being used instead of vectors
+    bool usingCSR;
+
+private:
+    AttributeMap<PerNode, Graph> nodeAttributeMap;
+    AttributeMap<PerEdge, Graph> edgeAttributeMap;
+
+public:
+    auto &nodeAttributes() noexcept { return nodeAttributeMap; }
+    const auto &nodeAttributes() const noexcept { return nodeAttributeMap; }
+    auto &edgeAttributes() noexcept { return edgeAttributeMap; }
+    const auto &edgeAttributes() const noexcept { return edgeAttributeMap; }
+
+    // wrap up some typed attributes for the cython interface:
+    //
+
+    auto attachNodeIntAttribute(const std::string &name) {
+        nodeAttributes().theGraph = this;
+        return nodeAttributes().attach<int>(name);
+    }
+
+    auto attachEdgeIntAttribute(const std::string &name) {
+        edgeAttributes().theGraph = this;
+        return edgeAttributes().attach<int>(name);
+    }
+
+    auto attachNodeDoubleAttribute(const std::string &name) {
+        nodeAttributes().theGraph = this;
+        return nodeAttributes().attach<double>(name);
+    }
+
+    auto attachEdgeDoubleAttribute(const std::string &name) {
+        edgeAttributes().theGraph = this;
+        return edgeAttributes().attach<double>(name);
+    }
+
+    auto attachNodeStringAttribute(const std::string &name) {
+        nodeAttributes().theGraph = this;
+        return nodeAttributes().attach<std::string>(name);
+    }
+
+    auto attachEdgeStringAttribute(const std::string &name) {
+        edgeAttributes().theGraph = this;
+        return edgeAttributes().attach<std::string>(name);
+    }
+
+    auto getNodeIntAttribute(const std::string &name) {
+        nodeAttributes().theGraph = this;
+        return nodeAttributes().get<int>(name);
+    }
+
+    auto getEdgeIntAttribute(const std::string &name) {
+        edgeAttributes().theGraph = this;
+        return edgeAttributes().get<int>(name);
+    }
+
+    auto getNodeDoubleAttribute(const std::string &name) {
+        nodeAttributes().theGraph = this;
+        return nodeAttributes().get<double>(name);
+    }
+
+    auto getEdgeDoubleAttribute(const std::string &name) {
+        edgeAttributes().theGraph = this;
+        return edgeAttributes().get<double>(name);
+    }
+
+    auto getNodeStringAttribute(const std::string &name) {
+        nodeAttributes().theGraph = this;
+        return nodeAttributes().get<std::string>(name);
+    }
+
+    auto getEdgeStringAttribute(const std::string &name) {
+        edgeAttributes().theGraph = this;
+        return edgeAttributes().get<std::string>(name);
+    }
+
+    void detachNodeAttribute(std::string const &name) {
+        nodeAttributes().theGraph = this;
+        nodeAttributes().detach(name);
+    }
+
+    void detachEdgeAttribute(std::string const &name) {
+        edgeAttributes().theGraph = this;
+        edgeAttributes().detach(name);
+    }
+
+    using NodeIntAttribute = Attribute<PerNode, Graph, int, false>;
+    using NodeDoubleAttribute = Attribute<PerNode, Graph, double, false>;
+    using NodeStringAttribute = Attribute<PerNode, Graph, std::string, false>;
+
+    using EdgeIntAttribute = Attribute<PerEdge, Graph, int, false>;
+    using EdgeDoubleAttribute = Attribute<PerEdge, Graph, double, false>;
+    using EdgeStringAttribute = Attribute<PerEdge, Graph, std::string, false>;
+
+    /**
+     * Copy all attributes from another graph. This is useful when creating
+     * a new graph with different properties (weighted/unweighted) but wanting
+     * to preserve attributes.
+     * @param other The source graph to copy attributes from.
+     */
+    void copyAttributesFrom(const Graph &other) {
+        nodeAttributeMap = AttributeMap<PerNode, Graph>(other.nodeAttributes(), this);
+        // Only copy edge attributes if both graphs have indexed edges
+        if (other.hasEdgeIds() && this->hasEdgeIds()) {
+            edgeAttributeMap = AttributeMap<PerEdge, Graph>(other.edgeAttributes(), this);
+        }
+    }
+
+protected:
+    /**
+     * Returns the index of node u in the array of incoming edges of node v.
+     * (for directed graphs inEdges is searched, while for indirected outEdges
+     * is searched, which gives the same result as indexInOutEdgeArray).
+     */
+    virtual index indexInInEdgeArray(node v, node u) const = 0;
+
+    /**
+     * Returns the index of node v in the array of outgoing edges of node u.
+     */
+    virtual index indexInOutEdgeArray(node u, node v) const = 0;
+
+    // CSR helper methods
+    /**
+     * Get neighbors of node u using CSR format for outgoing edges
+     */
+    std::pair<const node *, count> getCSROutNeighbors(node u) const;
+
+    /**
+     * Get neighbors of node u using CSR format for incoming edges
+     */
+    std::pair<const node *, count> getCSRInNeighbors(node u) const;
+
+    /**
+     * Check if edge (u,v) exists using CSR format
+     */
+    bool hasEdgeCSR(node u, node v) const;
+
+    /**
+     * Get degree of node using CSR format
+     */
+    count degreeCSR(node u, bool incoming = false) const;
+
+    /**
+     * Virtual method to get neighbors as a vector.
+     * This enables polymorphic iteration over neighbors regardless of storage format.
+     *
+     * @param u Node.
+     * @param inEdges If true, get incoming neighbors; otherwise outgoing.
+     * @return Vector of neighbor nodes (filtered to only existing nodes).
+     */
+    virtual std::vector<node> getNeighborsVector(node u, bool inEdges = false) const = 0;
+
+    /**
+     * Virtual method to get neighbors with weights as vectors.
+     * This enables polymorphic iteration over weighted neighbors regardless of storage format.
+     *
+     * @param u Node.
+     * @param inEdges If true, get incoming neighbors; otherwise outgoing.
+     * @return Pair of vectors: neighbors and corresponding weights (filtered to only existing
+     * nodes).
+     */
+    virtual std::pair<std::vector<node>, std::vector<edgeweight>>
+    getNeighborsWithWeightsVector(node u, bool inEdges = false) const = 0;
+
+private:
+    /**
+     * Computes the weighted in/out degree of node @a u.
+     *
+     * @param u Node.
+     * @param inDegree whether to compute the in degree or the out degree.
+     * @param countSelfLoopsTwice If set to true, self-loops will be counted twice.
+     *
+     * @return Weighted in/out degree of node @a u.
+     */
+    edgeweight computeWeightedDegree(node u, bool inDegree = false,
+                                     bool countSelfLoopsTwice = false) const;
+
+    /**
+     * Returns the edge weight of the outgoing edge of index i in the outgoing
+     * edges of node u
+     * @param u The node
+     * @param i The index
+     * @return The weight of the outgoing edge or defaultEdgeWeight if the graph
+     * is unweighted
+     */
+    template <bool hasWeights>
+    inline edgeweight getOutEdgeWeight(node u, index i) const;
+
+    /**
+     * Returns the edge weight of the incoming edge of index i in the incoming
+     * edges of node u
+     *
+     * @param u The node
+     * @param i The index in the incoming edge array
+     * @return The weight of the incoming edge
+     */
+    template <bool hasWeights>
+    inline edgeweight getInEdgeWeight(node u, index i) const;
+
+    /**
+     * Returns the edge id of the edge of index i in the outgoing edges of node
+     * u
+     *
+     * @param u The node
+     * @param i The index in the outgoing edges
+     * @return The edge id
+     */
+    template <bool graphHasEdgeIds>
+    inline edgeid getOutEdgeId(node u, index i) const;
+
+    /**
+     * Returns the edge id of the edge of index i in the incoming edges of node
+     * u
+     *
+     * @param u The node
+     * @param i The index in the incoming edges of u
+     * @return The edge id
+     */
+    template <bool graphHasEdgeIds>
+    inline edgeid getInEdgeId(node u, index i) const;
+
+    /**
+     * @brief Returns if the edge (u, v) shall be used in the iteration of all
+     * edgesIndexed
+     *
+     * @param u The source node of the edge
+     * @param v The target node of the edge
+     * @return If the node shall be used, i.e. if v is not none and in the
+     * undirected case if u >= v
+     */
+    template <bool graphIsDirected>
+    inline bool useEdgeInIteration(node u, node v) const;
+
+    /**
+     * @brief Implementation of the for loop for outgoing edges of u
+     *
+     * Note: If all (valid) outgoing edges shall be considered, graphIsDirected
+     * needs to be set to true
+     *
+     * @param u The node
+     * @param handle The handle that shall be executed for each edge
+     * @return void
+     */
+    // applyUndirectedFilter=true deduplicates edges (u>=v) for full-graph traversal.
+    // forEdgesOf / forNeighborsOf use the default false so all neighbors are returned.
+    template <bool graphIsDirected, bool hasWeights, bool graphHasEdgeIds, typename L,
+              bool applyUndirectedFilter = false>
+    inline void forOutEdgesOfImpl(node u, L handle) const;
+
+    /**
+     * @brief Implementation of the for loop for incoming edges of u
+     *
+     * For undirected graphs, this is the same as forOutEdgesOfImpl but u and v
+     * are changed in the handle
+     *
+     * @param u The node
+     * @param handle The handle that shall be executed for each edge
+     * @return void
+     */
+    template <bool graphIsDirected, bool hasWeights, bool graphHasEdgeIds, typename L>
+    inline void forInEdgesOfImpl(node u, L handle) const;
+
+    /**
+     * @brief Implementation of the for loop for all edges, @see forEdges
+     *
+     * @param handle The handle that shall be executed for all edges
+     * @return void
+     */
+    template <bool graphIsDirected, bool hasWeights, bool graphHasEdgeIds, typename L>
+    inline void forEdgeImpl(L handle) const;
+
+    /**
+     * @brief Parallel implementation of the for loop for all edges, @see
+     * parallelForEdges
+     *
+     * @param handle The handle that shall be executed for all edges
+     * @return void
+     */
+    template <bool graphIsDirected, bool hasWeights, bool graphHasEdgeIds, typename L>
+    inline void parallelForEdgesImpl(L handle) const;
+
+    /**
+     * @brief Summation variant of the parallel for loop for all edges, @see
+     * parallelSumForEdges
+     *
+     * @param handle The handle that shall be executed for all edges
+     * @return void
+     */
+    template <bool graphIsDirected, bool hasWeights, bool graphHasEdgeIds, typename L>
+    inline double parallelSumForEdgesImpl(L handle) const;
+
+    /**
+     * @brief Virtual method for edge iteration - overridden by GraphW for vector-based iteration
+     */
+    virtual void
+    forEdgesVirtualImpl(bool directed, bool weighted, bool hasEdgeIds,
+                        std::function<void(node, node, edgeweight, edgeid)> handle) const;
+
+    /**
+     * @brief Virtual method for forEdgesOf - overridden by GraphW for vector-based iteration
+     */
+    virtual void
+    forEdgesOfVirtualImpl(node u, bool directed, bool weighted, bool hasEdgeIds,
+                          std::function<void(node, node, edgeweight, edgeid)> handle) const;
+
+    /**
+     * @brief Virtual method for forInEdgesOf - overridden by GraphW for vector-based iteration
+     */
+    virtual void
+    forInEdgesVirtualImpl(node u, bool directed, bool weighted, bool hasEdgeIds,
+                          std::function<void(node, node, edgeweight, edgeid)> handle) const;
+
+    /**
+     * @brief Virtual method for parallelSumForEdges - overridden by GraphW for vector-based
+     * iteration
+     */
+    virtual double parallelSumForEdgesVirtualImpl(
+        bool directed, bool weighted, bool hasEdgeIds,
+        std::function<double(node, node, edgeweight, edgeid)> handle) const;
+
+    /*
+     * In the following definition, Aux::FunctionTraits is used in order to only
+     * execute lambda functions with the appropriate parameters. The
+     * decltype-return type is used for determining the return type of the
+     * lambda (needed for summation) but also determines if the lambda accepts
+     * the correct number of parameters. Otherwise the return type declaration
+     * fails and the function is excluded from overload resolution. Then there
+     * are multiple possible lambdas with three (third parameter id or weight)
+     * and two (second parameter can be second node id or edge weight for
+     * neighbor iterators). This is checked using Aux::FunctionTraits and
+     * std::enable_if. std::enable_if only defines the type member when the
+     * given bool is true, this bool comes from std::is_same which compares two
+     * types. The function traits give either the parameter type or if it is out
+     * of bounds they define type as void.
+     */
+
+    /**
+     * Triggers a static assert error when no other method is chosen. Because of
+     * the use of "..." as arguments, the priority of this method is lower than
+     * the priority of the other methods. This method avoids ugly and unreadable
+     * template substitution error messages from the other declarations.
+     */
+    template <class F, void * = (void *)0>
+    typename Aux::FunctionTraits<F>::result_type edgeLambda(F &, ...) const {
+        // the strange condition is used in order to delay the evaluation of the
+        // static assert to the moment when this function is actually used
+        static_assert(!std::is_same<F, F>::value,
+                      "Your lambda does not support the required parameters or the "
+                      "parameters have the wrong type.");
+        return std::declval<typename Aux::FunctionTraits<F>::result_type>(); // use the correct
+                                                                             // return type (this
+                                                                             // won't compile)
+    }
+
+    /**
+     * Calls the given function f if its fourth argument is of the type edgeid
+     * and third of type edgeweight Note that the decltype check is not enough
+     * as edgeweight can be casted to node and we want to assure that .
+     */
+    template <class F,
+              typename std::enable_if<
+                  (Aux::FunctionTraits<F>::arity >= 3)
+                  && std::is_same<edgeweight,
+                                  typename Aux::FunctionTraits<F>::template arg<2>::type>::value
+                  && std::is_same<edgeid, typename Aux::FunctionTraits<F>::template arg<3>::type>::
+                      value>::type * = (void *)0>
+    auto edgeLambda(F &f, node u, node v, edgeweight ew, edgeid id) const
+        -> decltype(f(u, v, ew, id)) {
+        return f(u, v, ew, id);
+    }
+
+    /**
+     * Calls the given function f if its third argument is of the type edgeid,
+     * discards the edge weight Note that the decltype check is not enough as
+     * edgeweight can be casted to node.
+     */
+    template <
+        class F,
+        typename std::enable_if<
+            (Aux::FunctionTraits<F>::arity >= 2)
+            && std::is_same<edgeid, typename Aux::FunctionTraits<F>::template arg<2>::type>::value
+            && std::is_same<node, typename Aux::FunctionTraits<F>::template arg<1>::type>::
+                value /* prevent f(v, weight, eid)
+                       */
+            >::type * = (void *)0>
+    auto edgeLambda(F &f, node u, node v, edgeweight, edgeid id) const -> decltype(f(u, v, id)) {
+        return f(u, v, id);
+    }
+
+    /**
+     * Calls the given function f if its third argument is of type edgeweight,
+     * discards the edge id Note that the decltype check is not enough as node
+     * can be casted to edgeweight.
+     */
+    template <class F,
+              typename std::enable_if<
+                  (Aux::FunctionTraits<F>::arity >= 2)
+                  && std::is_same<edgeweight, typename Aux::FunctionTraits<F>::template arg<
+                                                  2>::type>::value>::type * = (void *)0>
+    auto edgeLambda(F &f, node u, node v, edgeweight ew, edgeid /*id*/) const
+        -> decltype(f(u, v, ew)) {
+        return f(u, v, ew);
+    }
+
+    /**
+     * Calls the given function f if it has only two arguments and the second
+     * argument is of type node, discards edge weight and id Note that the
+     * decltype check is not enough as edgeweight can be casted to node.
+     */
+    template <class F, typename std::enable_if<
+                           (Aux::FunctionTraits<F>::arity >= 1)
+                           && std::is_same<node, typename Aux::FunctionTraits<F>::template arg<
+                                                     1>::type>::value>::type * = (void *)0>
+    auto edgeLambda(F &f, node u, node v, edgeweight /*ew*/, edgeid /*id*/) const
+        -> decltype(f(u, v)) {
+        return f(u, v);
+    }
+
+    /**
+     * Calls the given function f if it has only two arguments and the second
+     * argument is of type edgeweight, discards the first node and the edge id
+     * Note that the decltype check is not enough as edgeweight can be casted to
+     * node.
+     */
+    template <class F,
+              typename std::enable_if<
+                  (Aux::FunctionTraits<F>::arity >= 1)
+                  && std::is_same<edgeweight, typename Aux::FunctionTraits<F>::template arg<
+                                                  1>::type>::value>::type * = (void *)0>
+    auto edgeLambda(F &f, node, node v, edgeweight ew, edgeid /*id*/) const -> decltype(f(v, ew)) {
+        return f(v, ew);
+    }
+
+    /**
+     * Calls the given function f if it has only one argument, discards the
+     * first node id, the edge weight and the edge id
+     */
+    template <class F, void * = (void *)0>
+    auto edgeLambda(F &f, node, node v, edgeweight, edgeid) const -> decltype(f(v)) {
+        return f(v);
+    }
+
+    /**
+     * Calls the given BFS handle with distance parameter
+     */
+    template <class F>
+    auto callBFSHandle(F &f, node u, count dist) const -> decltype(f(u, dist)) {
+        return f(u, dist);
+    }
+
+    /**
+     * Calls the given BFS handle without distance parameter
+     */
+    template <class F>
+    auto callBFSHandle(F &f, node u, count) const -> decltype(f(u)) {
+        return f(u);
+    }
+
+public:
+    // For support of API: NetworKit::Graph::NodeIterator
+    using NodeIterator = NodeIteratorBase<Graph>;
+    // For support of API: NetworKit::Graph::NodeRange
+    using NodeRange = NodeRangeBase<Graph>;
+
+    // For support of API: NetworKit::Graph:EdgeIterator
+    using EdgeIterator = EdgeTypeIterator<Graph, Edge>;
+    // For support of API: NetworKit::Graph:EdgeWeightIterator
+    using EdgeWeightIterator = EdgeTypeIterator<Graph, WeightedEdge>;
+    // For support of API: NetworKit::Graph:EdgeRange
+    using EdgeRange = EdgeTypeRange<Graph, Edge>;
+    // For support of API: NetworKit::Graph:EdgeWeightRange
+    using EdgeWeightRange = EdgeTypeRange<Graph, WeightedEdge>;
+
+    // For support of API: NetworKit::Graph::NeighborIterator;
+    using NeighborIterator = NeighborIteratorBase<std::vector<node>>;
+    // For support of API: NetworKit::Graph::NeighborIterator;
+    using NeighborWeightIterator =
+        NeighborWeightIteratorBase<std::vector<node>, std::vector<edgeweight>>;
+
+    /**
+     * Wrapper class to iterate over a range of the neighbors of a node within
+     * a for loop.
+     */
+    template <bool InEdges = false>
+    class NeighborRange {
+        std::shared_ptr<std::vector<node>> neighborBuffer;
+
+    public:
+        NeighborRange(const Graph &G, node u)
+            : neighborBuffer(
+                std::make_shared<std::vector<node>>(G.getNeighborsVector(u, InEdges))) {}
+        NeighborRange() : neighborBuffer(std::make_shared<std::vector<node>>()) {}
+
+        NeighborIterator begin() const { return NeighborIterator(neighborBuffer->begin()); }
+
+        NeighborIterator end() const { return NeighborIterator(neighborBuffer->end()); }
+    };
+
+    using OutNeighborRange = NeighborRange<false>;
+
+    using InNeighborRange = NeighborRange<true>;
+    /**
+     * Wrapper class to iterate over a range of the neighbors of a node
+     * including the edge weights within a for loop.
+     * Values are std::pair<node, edgeweight>.
+     */
+    template <bool InEdges = false>
+    class NeighborWeightRange {
+        std::shared_ptr<std::vector<node>> neighborBuffer;
+        std::shared_ptr<std::vector<edgeweight>> weightBuffer;
+
+    public:
+        NeighborWeightRange(const Graph &G, node u) {
+            auto [neighbors, weights] = G.getNeighborsWithWeightsVector(u, InEdges);
+            neighborBuffer = std::make_shared<std::vector<node>>(std::move(neighbors));
+            weightBuffer = std::make_shared<std::vector<edgeweight>>(std::move(weights));
+        }
+        NeighborWeightRange()
+            : neighborBuffer(std::make_shared<std::vector<node>>()),
+              weightBuffer(std::make_shared<std::vector<edgeweight>>()) {}
+
+        NeighborWeightIterator begin() const {
+            return NeighborWeightIterator(
+                typename std::vector<node>::const_iterator(neighborBuffer->begin()),
+                typename std::vector<edgeweight>::const_iterator(weightBuffer->begin()));
+        }
+
+        NeighborWeightIterator end() const {
+            return NeighborWeightIterator(
+                typename std::vector<node>::const_iterator(neighborBuffer->end()),
+                typename std::vector<edgeweight>::const_iterator(weightBuffer->end()));
+        }
+    };
+
+    using OutNeighborWeightRange = NeighborWeightRange<false>;
+
+    using InNeighborWeightRange = NeighborWeightRange<true>;
+
+    /**
+     * Create a graph of @a n nodes. The graph has assignable edge weights if @a
+     * weighted is set to <code>true</code>. If @a weighted is set to
+     * <code>false</code> each edge has edge weight 1.0 and any other weight
+     * assignment will be ignored.
+     * @param n Number of nodes.
+     * @param weighted If set to <code>true</code>, the graph has edge weights.
+     * @param directed If set to @c true, the graph will be directed.
+     */
+    Graph(count n = 0, bool weighted = false, bool directed = false, bool edgesIndexed = false);
+
+    template <class EdgeMerger = std::plus<edgeweight>>
+    Graph(const Graph &G, bool weighted, bool directed, bool edgesIndexed = false,
+          [[maybe_unused]] EdgeMerger edgeMerger = std::plus<edgeweight>())
+        : n(G.n), m(G.m), storedNumberOfSelfLoops(G.storedNumberOfSelfLoops), z(G.z),
+          omega(edgesIndexed ? G.omega : 0), t(G.t), weighted(weighted), directed(directed),
+          edgesIndexed(edgesIndexed),        // edges are not indexed by default
+          exists(G.exists), usingCSR(false), // Base Graph doesn't use CSR by default
+
+          // copy node attribute map
+          nodeAttributeMap(G.nodeAttributeMap, this),
+          // fill this later
+          edgeAttributeMap(this) {
+
+        // Base Graph class only supports CSR format and is immutable
+        throw std::runtime_error("Graph template copy constructor not supported in base Graph "
+                                 "class - use GraphW for conversions and mutable operations");
+    }
+
+    /**
+     * Generate a weighted graph from a list of edges. (Useful for small
+     * graphs in unit tests that you do not want to read from a file.)
+     *
+     * @param[in] edges list of weighted edges
+     */
+    Graph(std::initializer_list<WeightedEdge> edges);
+
+    /**
+     * Create a graph from CSR arrays for memory-efficient storage.
+     *
+     * @param n Number of nodes.
+     * @param directed If set to @c true, the graph will be directed.
+     * @param outIndices CSR indices array containing neighbor node IDs for outgoing edges
+     * @param outIndptr CSR indptr array containing offsets into outIndices for each node
+     * @param inIndices CSR indices array containing neighbor node IDs for incoming edges (directed
+     * only)
+     * @param inIndptr CSR indptr array containing offsets into inIndices for each node (directed
+     * only)
+     */
+    Graph(count n, bool directed, std::vector<node> outIndices, std::vector<index> outIndptr,
+          std::vector<node> inIndices = {}, std::vector<index> inIndptr = {});
+
+    /**
+     * Create a graph as copy of @a other.
+     * @param other The graph to copy.
+     */
+    Graph(const Graph &other)
+        : n(other.n), m(other.m), storedNumberOfSelfLoops(other.storedNumberOfSelfLoops),
+          z(other.z), omega(other.omega), t(other.t), weighted(other.weighted),
+          directed(other.directed), edgesIndexed(other.edgesIndexed), deletedID(other.deletedID),
+          exists(other.exists), outEdgesCSRIndices(other.outEdgesCSRIndices),
+          outEdgesCSRIndptr(other.outEdgesCSRIndptr), inEdgesCSRIndices(other.inEdgesCSRIndices),
+          inEdgesCSRIndptr(other.inEdgesCSRIndptr), outEdgesCSRWeights(other.outEdgesCSRWeights),
+          inEdgesCSRWeights(other.inEdgesCSRWeights), usingCSR(other.usingCSR),
+          // call special constructors to copy attribute maps
+          nodeAttributeMap(other.nodeAttributeMap, this),
+          edgeAttributeMap(other.edgeAttributeMap, this) {
+
+        // Only support copying CSR-based graphs
+        if (!other.usingCSR) {
+            throw std::runtime_error("Graph copy constructor only supports CSR-based graphs. Use "
+                                     "GraphW for vector-based graphs.");
+        }
+    }
+
+protected:
+    /**
+     * Protected copy constructor for subclasses (like GraphW) that use vector-based storage.
+     * This constructor copies the graph without requiring CSR format.
+     * @param other The graph to copy.
+     * @param subclassCopy Flag to indicate this is a subclass copy (bypass CSR check).
+     */
+    Graph(const Graph &other, bool subclassCopy)
+        : n(other.n), m(other.m), storedNumberOfSelfLoops(other.storedNumberOfSelfLoops),
+          z(other.z), omega(other.omega), t(other.t), weighted(other.weighted),
+          directed(other.directed), edgesIndexed(other.edgesIndexed), deletedID(other.deletedID),
+          exists(other.exists), outEdgesCSRIndices(other.outEdgesCSRIndices),
+          outEdgesCSRIndptr(other.outEdgesCSRIndptr), inEdgesCSRIndices(other.inEdgesCSRIndices),
+          inEdgesCSRIndptr(other.inEdgesCSRIndptr), outEdgesCSRWeights(other.outEdgesCSRWeights),
+          inEdgesCSRWeights(other.inEdgesCSRWeights), usingCSR(other.usingCSR),
+          // call special constructors to copy attribute maps
+          nodeAttributeMap(other.nodeAttributeMap, this),
+          edgeAttributeMap(other.edgeAttributeMap, this) {
+        // This constructor is for subclasses only - no CSR check
+        (void)subclassCopy; // Suppress unused parameter warning
+    }
+
+public:
+    /** move constructor */
+    Graph(Graph &&other) noexcept
+        : n(other.n), m(other.m), storedNumberOfSelfLoops(other.storedNumberOfSelfLoops),
+          z(other.z), omega(other.omega), t(other.t), weighted(other.weighted),
+          directed(other.directed), edgesIndexed(other.edgesIndexed), deletedID(other.deletedID),
+          exists(std::move(other.exists)), outEdgesCSRIndices(std::move(other.outEdgesCSRIndices)),
+          outEdgesCSRIndptr(std::move(other.outEdgesCSRIndptr)),
+          inEdgesCSRIndices(std::move(other.inEdgesCSRIndices)),
+          inEdgesCSRIndptr(std::move(other.inEdgesCSRIndptr)),
+          outEdgesCSRWeights(std::move(other.outEdgesCSRWeights)),
+          inEdgesCSRWeights(std::move(other.inEdgesCSRWeights)), usingCSR(other.usingCSR),
+          nodeAttributeMap(std::move(other.nodeAttributeMap)),
+          edgeAttributeMap(std::move(other.edgeAttributeMap)) {
+        // attributes: set graph pointer to this new graph
+        nodeAttributeMap.theGraph = this;
+        edgeAttributeMap.theGraph = this;
+    };
+
+    virtual ~Graph() = default;
+
+    /**
+     * Constructor that creates a graph from Arrow CSR arrays for zero-copy memory efficiency.
+     * @param n Number of nodes.
+     * @param directed If set to @c true, the graph will be directed.
+     * @param outIndices Arrow array containing neighbor node IDs for outgoing edges (CSR indices).
+     * @param outIndptr Arrow array containing offsets into outIndices for each node (CSR indptr).
+     * @param inIndices Arrow array containing neighbor node IDs for incoming edges (only for
+     * directed graphs).
+     * @param inIndptr Arrow array containing offsets into inIndices for each node (only for
+     * directed graphs).
+     * @param outWeights Arrow array containing edge weights for outgoing edges (optional).
+     * @param inWeights Arrow array containing edge weights for incoming edges (optional, only for
+     * directed graphs).
+     */
+    Graph(count n, bool directed, std::shared_ptr<arrow::UInt64Array> outIndices,
+          std::shared_ptr<arrow::UInt64Array> outIndptr,
+          std::shared_ptr<arrow::UInt64Array> inIndices = nullptr,
+          std::shared_ptr<arrow::UInt64Array> inIndptr = nullptr,
+          std::shared_ptr<arrow::DoubleArray> outWeights = nullptr,
+          std::shared_ptr<arrow::DoubleArray> inWeights = nullptr);
+
+    /** move assignment operator */
+    Graph &operator=(Graph &&other) noexcept {
+        std::swap(n, other.n);
+        std::swap(m, other.m);
+        std::swap(storedNumberOfSelfLoops, other.storedNumberOfSelfLoops);
+        std::swap(z, other.z);
+        std::swap(omega, other.omega);
+        std::swap(t, other.t);
+        std::swap(weighted, other.weighted);
+        std::swap(directed, other.directed);
+        std::swap(edgesIndexed, other.edgesIndexed);
+        std::swap(exists, other.exists);
+        std::swap(usingCSR, other.usingCSR);
+        std::swap(outEdgesCSRIndices, other.outEdgesCSRIndices);
+        std::swap(outEdgesCSRIndptr, other.outEdgesCSRIndptr);
+        std::swap(inEdgesCSRIndices, other.inEdgesCSRIndices);
+        std::swap(inEdgesCSRIndptr, other.inEdgesCSRIndptr);
+        std::swap(outEdgesCSRWeights, other.outEdgesCSRWeights);
+        std::swap(inEdgesCSRWeights, other.inEdgesCSRWeights);
+        std::swap(deletedID, other.deletedID);
+
+        // attributes: set graph pointer to this new graph
+        std::swap(nodeAttributeMap, other.nodeAttributeMap);
+        std::swap(edgeAttributeMap, other.edgeAttributeMap);
+        nodeAttributeMap.theGraph = this;
+        edgeAttributeMap.theGraph = this;
+
+        return *this;
+    };
+
+    /** copy assignment operator */
+    Graph &operator=(const Graph &other) {
+        n = other.n;
+        m = other.m;
+        storedNumberOfSelfLoops = other.storedNumberOfSelfLoops;
+        z = other.z;
+        omega = other.omega;
+        t = other.t;
+        weighted = other.weighted;
+        directed = other.directed;
+        edgesIndexed = other.edgesIndexed;
+        exists = other.exists;
+        deletedID = other.deletedID;
+
+        // call special constructors to copy attribute maps
+        nodeAttributeMap = AttributeMap(other.nodeAttributeMap, this);
+        edgeAttributeMap = AttributeMap(other.edgeAttributeMap, this);
+
+        return *this;
+    };
+
+    /** EDGE IDS **/
+
+    /**
+     * Checks if edges have been indexed
+     *
+     * @return bool if edges have been indexed
+     */
+    bool hasEdgeIds() const noexcept { return edgesIndexed; }
+
+    /**
+     * Get the id of the given edge.
+     */
+    virtual edgeid edgeId(node u, node v) const = 0;
+
+    /**
+     * Get the Edge (u,v) of the given id. (inverse to edgeId)
+     * @note Time complexity of this function is O(n).
+     */
+    std::pair<node, node> edgeById(index id) const {
+        std::pair<node, node> result{none, none};
+        bool found = false;
+
+        forNodesWhile([&] { return !found; },
+                      [&](node u) {
+                          forNeighborsOf(u, [&](node v) {
+                              if (!this->isDirected() && v < u)
+                                  return;
+                              auto uvId = edgeId(u, v);
+                              if (uvId == id) {
+                                  found = true;
+                                  result = std::make_pair(u, v);
+                              }
+                          });
+                      });
+
+        return result;
+    }
+
+    /**
+     * Get an upper bound for the edge ids in the graph.
+     * @return An upper bound for the edge ids.
+     */
+    index upperEdgeIdBound() const noexcept { return omega; }
+
+    /** GRAPH INFORMATION **/
+
+    /**
+     * DEPRECATED: this function will no longer be supported in later releases.
+     * Compacts the adjacency arrays by re-using no longer needed slots from
+     * deleted edges.
+     */
+
+    /**
+     * Check if node @a v exists in the graph.
+     *
+     * @param v Node.
+     * @return @c true if @a v exists, @c false otherwise.
+     */
+
+    bool hasNode(node v) const noexcept { return (v < z) && this->exists[v]; }
+
+    /**
+     * Check if edge (u, v) exists in the graph.
+     *
+     * @param u First endpoint of edge.
+     * @param v Second endpoint of edge.
+     * @return @c true if edge exists, @c false otherwise.
+     */
+    bool hasEdge(node u, node v) const;
+
+    /**
+     * @brief Virtual method for hasEdge - overridden by GraphW for vector-based graphs
+     */
+    virtual bool hasEdgeImpl(node u, node v) const;
+
+    /**
+     * Remove adjacent edges satisfying a condition.
+     *
+     * @param u Node.
+     * @param condition A function that takes a node and returns true if the edge should be removed.
+     * @param edgesIn Whether to consider incoming edges.
+     * @return A pair of (number of removed edges, number of checked edges).
+     */
+    template <typename Condition>
+    std::pair<count, count> removeAdjacentEdges(node u, Condition condition, bool edgesIn = false);
+
+    /** NODE PROPERTIES **/
+    /**
+     * Returns the number of outgoing neighbors of @a v.
+     *
+     * @param v Node.
+     * @return The number of outgoing neighbors.
+     * @note The existence of the node is not checked. Calling this function with a non-existing
+     * node results in a segmentation fault. Node existence can be checked by calling hasNode(u).
+     */
+    virtual count degree(node v) const = 0;
+
+    /**
+     * Get the number of incoming neighbors of @a v.
+     *
+     * @param v Node.
+     * @return The number of incoming neighbors.
+     * @note If the graph is not directed, the outgoing degree is returned.
+     * @note The existence of the node is not checked. Calling this function with a non-existing
+     * node results in a segmentation fault. Node existence can be checked by calling hasNode(u).
+     */
+    virtual count degreeIn(node v) const = 0;
+
+    /**
+     * Get the number of outgoing neighbors of @a v.
+     *
+     * @param v Node.
+     * @return The number of outgoing neighbors.
+     * @note The existence of the node is not checked. Calling this function with a non-existing
+     * node results in a segmentation fault. Node existence can be checked by calling hasNode(u).
+     */
+    count degreeOut(node v) const { return degree(v); }
+
+    /**
+     * Check whether @a v is isolated, i.e. degree is 0.
+     * @param v Node.
+     * @return @c true if the node is isolated (= degree is 0)
+     */
+    virtual bool isIsolated(node v) const = 0;
+
+    /**
+     * Returns the weighted degree of @a u.
+     *
+     * @param u Node.
+     * @param countSelfLoopsTwice If set to true, self-loops will be counted twice.
+     *
+     * @return Weighted degree of @a u.
+     */
+    edgeweight weightedDegree(node u, bool countSelfLoopsTwice = false) const;
+
+    /**
+     * Returns the weighted in-degree of @a u.
+     *
+     * @param u Node.
+     * @param countSelfLoopsTwice If set to true, self-loops will be counted twice.
+     *
+     * @return Weighted in-degree of @a v.
+     */
+    edgeweight weightedDegreeIn(node u, bool countSelfLoopsTwice = false) const;
+
+    /**
+     * Returns <code>true</code> if this graph supports edge weights other
+     * than 1.0.
+     * @return <code>true</code> if this graph supports edge weights other
+     * than 1.0.
+     */
+    bool isWeighted() const noexcept { return weighted; }
+
+    /**
+     * Return @c true if this graph supports directed edges.
+     * @return @c true if this graph supports directed edges.
+     */
+    bool isDirected() const noexcept { return directed; }
+
+    /**
+     * Return <code>true</code> if graph contains no nodes.
+     * @return <code>true</code> if graph contains no nodes.
+     */
+    bool isEmpty() const noexcept { return !n; }
+
+    /**
+     * Return the number of nodes in the graph.
+     * @return The number of nodes.
+     */
+    count numberOfNodes() const noexcept { return n; }
+
+    /**
+     * Return the number of edges in the graph.
+     * @return The number of edges.
+     */
+    count numberOfEdges() const noexcept { return m; }
+
+    /**
+     * Return the number of loops {v,v} in the graph.
+     * @return The number of loops.
+     */
+    count numberOfSelfLoops() const noexcept { return storedNumberOfSelfLoops; }
+
+    /**
+     * Get an upper bound for the node ids in the graph.
+     * @return An upper bound for the node ids.
+     */
+    index upperNodeIdBound() const noexcept { return z; }
+
+    /**
+     * Returns true if edges are currently being sorted when removeEdge() is called.
+     */
+    bool getKeepEdgesSorted() const noexcept { return maintainSortedEdges; }
+
+    /**
+     * Returns true if edges are currently being compacted when removeEdge() is called.
+     */
+    bool getMaintainCompactEdges() const noexcept { return maintainCompactEdges; }
+
+    /**
+     * Check for invalid graph states, such as multi-edges.
+     * @return False if the graph is in invalid state.
+     */
+    virtual bool checkConsistency() const;
+
+    /* DYNAMICS */
+
+    /**
+     * Trigger a time step - increments counter.
+     *
+     * This method is deprecated and will not be supported in future releases.
+     */
+    void timeStep() {
+        WARN("Graph::timeStep should not be used and will be deprecated in the future.");
+        t++;
+    }
+
+    /**
+     * Get time step counter.
+     * @return Time step counter.
+     *
+     * This method is deprecated and will not be supported in future releases.
+     */
+    count time() {
+        WARN("Graph::time should not be used and will be deprecated in the future.");
+        return t;
+    }
+
+    /**
+     * Return edge weight of edge {@a u,@a v}. Returns 0 if edge does not
+     * exist. BEWARE: Running time is \Theta(deg(u))!
+     *
+     * @param u Endpoint of edge.
+     * @param v Endpoint of edge.
+     * @return Edge weight of edge {@a u,@a v} or 0 if edge does not exist.
+     */
+    virtual edgeweight weight(node u, node v) const;
+
+    /**
+     * Set the weight to the i-th neighbour of u.
+     *
+     * @param[in]	u	endpoint of edge
+     * @param[in]	i	index of the nexight
+     * @param[in]	ew	edge weight
+     */
+    virtual void setWeightAtIthNeighbor(Unsafe, node u, index i, edgeweight ew);
+
+    /**
+     * Set the weight to the i-th incoming neighbour of u.
+     *
+     * @param[in]	u	endpoint of edge
+     * @param[in]	i	index of the nexight
+     * @param[in]	ew	edge weight
+     */
+    virtual void setWeightAtIthInNeighbor(Unsafe, node u, index i, edgeweight ew);
+
+    /* SUMS */
+
+    /**
+     * Returns the sum of all edge weights.
+     * @return The sum of all edge weights.
+     */
+    edgeweight totalEdgeWeight() const noexcept;
+
+    /**
+     * Return the i-th (outgoing) neighbor of @a u.
+     *
+     * @param u Node.
+     * @param i index; should be in [0, degreeOut(u))
+     * @return @a i-th (outgoing) neighbor of @a u, or @c none if no such
+     * neighbor exists.
+     */
+    virtual node getIthNeighbor(Unsafe, node u, index i) const = 0;
+
+    /**
+     * Return the weight to the i-th (outgoing) neighbor of @a u.
+     *
+     * @param u Node.
+     * @param i index; should be in [0, degreeOut(u))
+     * @return @a edge weight to the i-th (outgoing) neighbor of @a u, or @c +inf if no such
+     * neighbor exists.
+     */
+    virtual edgeweight getIthNeighborWeight(node u, index i) const = 0;
+
+    /**
+     * Return the weight to the i-th (outgoing) neighbor of @a u - unsafe version
+     * that assumes valid indices.
+     *
+     * @param u Node.
+     * @param i index.
+     * @return @a edge weight to the i-th (outgoing) neighbor of @a u.
+     */
+    edgeweight getIthNeighborWeight(Unsafe, node u, index i) const {
+        return getIthNeighborWeight(u, i);
+    }
+
+    /**
+     * Get an iterable range over the nodes of the graph.
+     *
+     * @return Iterator range over the nodes of the graph.
+     */
+    NodeRange nodeRange() const noexcept { return NodeRange(*this); }
+
+    /**
+     * Get an iterable range over the edges of the graph.
+     *
+     * @return Iterator range over the edges of the graph.
+     */
+    EdgeRange edgeRange() const noexcept { return EdgeRange(*this); }
+
+    /**
+     * Get an iterable range over the edges of the graph and their weights.
+     *
+     * @return Iterator range over the edges of the graph and their weights.
+     */
+    EdgeWeightRange edgeWeightRange() const noexcept { return EdgeWeightRange(*this); }
+
+    /**
+     * Get an iterable range over the neighbors of @a.
+     *
+     * @param u Node.
+     * @return Iterator range over the neighbors of @a u.
+     */
+    NeighborRange<false> neighborRange(node u) const {
+        assert(exists[u]);
+        return NeighborRange<false>(*this, u);
+    }
+
+    /**
+     * Get an iterable range over the neighbors of @a u including the edge
+     * weights.
+     *
+     * @param u Node.
+     * @return Iterator range over pairs of neighbors of @a u and corresponding
+     * edge weights.
+     */
+    NeighborWeightRange<false> weightNeighborRange(node u) const {
+        assert(isWeighted());
+        assert(exists[u]);
+        return NeighborWeightRange<false>(*this, u);
+    }
+
+    /**
+     * Get an iterable range over the in-neighbors of @a.
+     *
+     * @param u Node.
+     * @return Iterator range over pairs of in-neighbors of @a u.
+     */
+    NeighborRange<true> inNeighborRange(node u) const {
+        assert(isDirected());
+        assert(exists[u]);
+        return NeighborRange<true>(*this, u);
+    }
+
+    /**
+     * Get an iterable range over the in-neighbors of @a u including the
+     * edge weights.
+     *
+     * @param u Node.
+     * @return Iterator range over pairs of in-neighbors of @a u and corresponding
+     * edge weights.
+     */
+    NeighborWeightRange<true> weightInNeighborRange(node u) const {
+        assert(isDirected() && isWeighted());
+        assert(exists[u]);
+        return NeighborWeightRange<true>(*this, u);
+    }
+
+    /**
+     * Returns the index of node v in the array of outgoing edges of node u.
+     *
+     * @param u Node
+     * @param v Node
+     * @return index of node v in the array of outgoing edges of node u.
+     */
+    index indexOfNeighbor(node u, node v) const { return indexInOutEdgeArray(u, v); }
+
+    /**
+     * Return the i-th (outgoing) neighbor of @a u.
+     *
+     * @param u Node.
+     * @param i index; should be in [0, degreeOut(u))
+     * @return @a i-th (outgoing) neighbor of @a u, or @c none if no such
+     * neighbor exists.
+     */
+    virtual node getIthNeighbor(node u, index i) const = 0;
+
+    /**
+     * Return the i-th (incoming) neighbor of @a u.
+     *
+     * @param u Node.
+     * @param i index; should be in [0, degreeIn(u))
+     * @return @a i-th (incoming) neighbor of @a u, or @c none if no such
+     * neighbor exists.
+     */
+    virtual node getIthInNeighbor(node u, index i) const = 0;
+
+    /**
+     * Return the weight to the i-th (outgoing) neighbor of @a u.
+     *
+     * @param u Node.
+     * @param i index; should be in [0, degreeOut(u))
+     * @return @a edge weight to the i-th (outgoing) neighbor of @a u, or @c +inf if no such
+     * neighbor exists.
+     */
+
+    /**
+     * Get i-th (outgoing) neighbor of @a u and the corresponding edge weight.
+     *
+     * @param u Node.
+     * @param i index; should be in [0, degreeOut(u))
+     * @return pair: i-th (outgoing) neighbor of @a u and the corresponding
+     * edge weight, or @c defaultEdgeWeight if unweighted.
+     */
+    virtual std::pair<node, edgeweight> getIthNeighborWithWeight(node u, index i) const = 0;
+
+    /**
+     * Get i-th (outgoing) neighbor of @a u and the corresponding edge weight - unsafe version.
+     *
+     * @param u Node.
+     * @param i index.
+     * @return pair: i-th (outgoing) neighbor of @a u and the corresponding edge weight.
+     */
+    std::pair<node, edgeweight> getIthNeighborWithWeight(Unsafe, node u, index i) const {
+        return getIthNeighborWithWeight(u, i);
+    }
+
+    /**
+     * Get i-th (outgoing) neighbor of @a u and the corresponding edge id.
+     *
+     * @param u Node.
+     * @param i index; should be in [0, degreeOut(u))
+     * @return pair: i-th (outgoing) neighbor of @a u and the corresponding
+     * edge id, or @c none if no such neighbor exists.
+     */
+    virtual std::pair<node, edgeid> getIthNeighborWithId(node u, index i) const = 0;
+
+    /* NODE ITERATORS */
+
+    /**
+     * Iterate over all nodes of the graph and call @a handle (lambda
+     * closure).
+     *
+     * @param handle Takes parameter <code>(node)</code>.
+     */
+    template <typename L>
+    void forNodes(L handle) const;
+
+    /**
+     * Iterate randomly over all nodes of the graph and call @a handle (lambda
+     * closure).
+     *
+     * @param handle Takes parameter <code>(node)</code>.
+     */
+    template <typename L>
+    void parallelForNodes(L handle) const;
+
+    /** Iterate over all nodes of the graph and call @a handle (lambda
+     * closure) as long as @a condition remains true. This allows for breaking
+     * from a node loop.
+     *
+     * @param condition Returning <code>false</code> breaks the loop.
+     * @param handle Takes parameter <code>(node)</code>.
+     */
+    template <typename C, typename L>
+    void forNodesWhile(C condition, L handle) const;
+
+    /**
+     * Iterate randomly over all nodes of the graph and call @a handle (lambda
+     * closure).
+     *
+     * @param handle Takes parameter <code>(node)</code>.
+     */
+    template <typename L>
+    void forNodesInRandomOrder(L handle) const;
+
+    /**
+     * Iterate in parallel over all nodes of the graph and call handler
+     * (lambda closure). Using schedule(guided) to remedy load-imbalances due
+     * to e.g. unequal degree distribution.
+     *
+     * @param handle Takes parameter <code>(node)</code>.
+     */
+    template <typename L>
+    void balancedParallelForNodes(L handle) const;
+
+    /**
+     * Iterate over all undirected pairs of nodes and call @a handle (lambda
+     * closure).
+     *
+     * @param handle Takes parameters <code>(node, node)</code>.
+     */
+    template <typename L>
+    void forNodePairs(L handle) const;
+
+    /**
+     * Iterate over all undirected pairs of nodes in parallel and call @a
+     * handle (lambda closure).
+     *
+     * @param handle Takes parameters <code>(node, node)</code>.
+     */
+    template <typename L>
+    void parallelForNodePairs(L handle) const;
+
+    /* EDGE ITERATORS */
+
+    /**
+     * Iterate over all edges of the const graph and call @a handle (lambda
+     * closure).
+     *
+     * @param handle Takes parameters <code>(node, node)</code>, <code>(node,
+     * node, edgweight)</code>, <code>(node, node, edgeid)</code> or
+     * <code>(node, node, edgeweight, edgeid)</code>.
+     */
+    template <typename L>
+    void forEdges(L handle) const;
+
+    /**
+     * Iterate in parallel over all edges of the const graph and call @a
+     * handle (lambda closure).
+     *
+     * @param handle Takes parameters <code>(node, node)</code> or
+     * <code>(node, node, edgweight)</code>, <code>(node, node, edgeid)</code>
+     * or <code>(node, node, edgeweight, edgeid)</code>.
+     */
+    template <typename L>
+    void parallelForEdges(L handle) const;
+
+    /* NEIGHBORHOOD ITERATORS */
+
+    /**
+     * Iterate over all neighbors of a node and call @a handle (lamdba
+     * closure).
+     *
+     * @param u Node.
+     * @param handle Takes parameter <code>(node)</code> or <code>(node,
+     * edgeweight)</code> which is a neighbor of @a u.
+     * @note For directed graphs only outgoing edges from @a u are considered.
+     * A node is its own neighbor if there is a self-loop.
+     *
+     */
+    template <typename L>
+    void forNeighborsOf(node u, L handle) const;
+
+    /**
+     * Iterate over all incident edges of a node and call @a handle (lamdba
+     * closure).
+     *
+     * @param u Node.
+     * @param handle Takes parameters <code>(node, node)</code>, <code>(node,
+     * node, edgeweight)</code>, <code>(node, node, edgeid)</code> or
+     * <code>(node, node, edgeweight, edgeid)</code> where the first node is
+     * @a u and the second is a neighbor of @a u.
+     * @note For undirected graphs all edges incident to @a u are also
+     * outgoing edges.
+     */
+    template <typename L>
+    void forEdgesOf(node u, L handle) const;
+
+    /**
+     * Iterate over all neighbors of a node and call handler (lamdba closure).
+     * For directed graphs only incoming edges from u are considered.
+     */
+    template <typename L>
+    void forInNeighborsOf(node u, L handle) const;
+
+    /**
+     * Iterate over all incoming edges of a node and call handler (lamdba
+     * closure).
+     * @note For undirected graphs all edges incident to u are also incoming
+     * edges.
+     *
+     * Handle takes parameters (u, v) or (u, v, w) where w is the edge weight.
+     */
+    template <typename L>
+    void forInEdgesOf(node u, L handle) const;
+
+    /* REDUCTION ITERATORS */
+
+    /**
+     * Iterate in parallel over all nodes and sum (reduce +) the values
+     * returned by the handler
+     */
+    template <typename L>
+    double parallelSumForNodes(L handle) const;
+
+    /**
+     * Iterate in parallel over all edges and sum (reduce +) the values
+     * returned by the handler
+     */
+    template <typename L>
+    double parallelSumForEdges(L handle) const;
+};
+
+/* NODE ITERATORS */
+
+template <typename L>
+void Graph::forNodes(L handle) const {
+    for (node v = 0; v < z; ++v) {
+        if (exists[v]) {
+            handle(v);
+        }
+    }
+}
+
+template <typename L>
+void Graph::parallelForNodes(L handle) const {
+    if (usingCSR) {
+        // For immutable CSR graphs, all nodes exist - skip exists check for thread safety
+#pragma omp parallel for
+        for (omp_index v = 0; v < static_cast<omp_index>(z); ++v) {
+            handle(v);
+        }
+    } else {
+        // For mutable graphs, check exists
+#pragma omp parallel for
+        for (omp_index v = 0; v < static_cast<omp_index>(z); ++v) {
+            if (exists[v]) {
+                handle(v);
+            }
+        }
+    }
+}
+
+template <typename C, typename L>
+void Graph::forNodesWhile(C condition, L handle) const {
+    for (node v = 0; v < z; ++v) {
+        if (exists[v]) {
+            if (!condition()) {
+                break;
+            }
+            handle(v);
+        }
+    }
+}
+
+template <typename L>
+void Graph::forNodesInRandomOrder(L handle) const {
+    std::vector<node> randVec;
+    randVec.reserve(numberOfNodes());
+    forNodes([&](node u) { randVec.push_back(u); });
+    std::ranges::shuffle(randVec, Aux::Random::getURNG());
+    for (node v : randVec) {
+        handle(v);
+    }
+}
+
+template <typename L>
+void Graph::balancedParallelForNodes(L handle) const {
+    // TODO: define min block size (and test it!)
+    if (usingCSR) {
+        // For immutable CSR graphs, all nodes exist - skip exists check for thread safety
+#pragma omp parallel for schedule(guided)
+        for (omp_index v = 0; v < static_cast<omp_index>(z); ++v) {
+            handle(v);
+        }
+    } else {
+        // For mutable graphs, check exists
+#pragma omp parallel for schedule(guided)
+        for (omp_index v = 0; v < static_cast<omp_index>(z); ++v) {
+            if (exists[v]) {
+                handle(v);
+            }
+        }
+    }
+}
+
+template <typename L>
+void Graph::forNodePairs(L handle) const {
+    for (node u = 0; u < z; ++u) {
+        if (exists[u]) {
+            for (node v = u + 1; v < z; ++v) {
+                if (exists[v]) {
+                    handle(u, v);
+                }
+            }
+        }
+    }
+}
+
+template <typename L>
+void Graph::parallelForNodePairs(L handle) const {
+    if (usingCSR) {
+        // For immutable CSR graphs, all nodes exist - skip exists check for thread safety
+#pragma omp parallel for schedule(guided)
+        for (omp_index u = 0; u < static_cast<omp_index>(z); ++u) {
+            for (node v = u + 1; v < z; ++v) {
+                handle(u, v);
+            }
+        }
+    } else {
+        // For mutable graphs, check exists
+#pragma omp parallel for schedule(guided)
+        for (omp_index u = 0; u < static_cast<omp_index>(z); ++u) {
+            if (exists[u]) {
+                for (node v = u + 1; v < z; ++v) {
+                    if (exists[v]) {
+                        handle(u, v);
+                    }
+                }
+            }
+        }
+    }
+}
+
+/* EDGE ITERATORS */
+
+/* HELPERS */
+
+template <typename T>
+void erase(node u, index idx, std::vector<std::vector<T>> &vec);
+// implementation for weighted == true
+template <bool hasWeights>
+inline edgeweight Graph::getOutEdgeWeight([[maybe_unused]] node u, [[maybe_unused]] index i) const {
+    // Base Graph class only supports CSR format
+    throw std::runtime_error(
+        "getOutEdgeWeight not supported in base Graph class - use GraphW for mutable operations");
+}
+
+// implementation for weighted == false
+template <>
+inline edgeweight Graph::getOutEdgeWeight<false>(node, index) const {
+    return defaultEdgeWeight;
+}
+
+// implementation for weighted == true
+template <bool hasWeights>
+inline edgeweight Graph::getInEdgeWeight([[maybe_unused]] node u, [[maybe_unused]] index i) const {
+    // Base Graph class only supports CSR format
+    throw std::runtime_error(
+        "getInEdgeWeight not supported in base Graph class - use GraphW for mutable operations");
+}
+
+// implementation for weighted == false
+template <>
+inline edgeweight Graph::getInEdgeWeight<false>(node, index) const {
+    return defaultEdgeWeight;
+}
+
+// implementation for hasEdgeIds == true
+template <bool graphHasEdgeIds>
+inline edgeid Graph::getOutEdgeId([[maybe_unused]] node u, [[maybe_unused]] index i) const {
+    // Base Graph class only supports CSR format
+    throw std::runtime_error(
+        "getOutEdgeId not supported in base Graph class - use GraphW for mutable operations");
+}
+
+// implementation for hasEdgeIds == false
+template <>
+inline edgeid Graph::getOutEdgeId<false>(node, index) const {
+    return none;
+}
+
+// implementation for hasEdgeIds == true
+template <bool graphHasEdgeIds>
+inline edgeid Graph::getInEdgeId([[maybe_unused]] node u, [[maybe_unused]] index i) const {
+    // Base Graph class only supports CSR format
+    throw std::runtime_error(
+        "getInEdgeId not supported in base Graph class - use GraphW for mutable operations");
+}
+
+// implementation for hasEdgeIds == false
+template <>
+inline edgeid Graph::getInEdgeId<false>(node, index) const {
+    return none;
+}
+
+// implementation for graphIsDirected == true
+template <bool graphIsDirected>
+inline bool Graph::useEdgeInIteration(node /* u */, node /* v */) const {
+    return true;
+}
+
+// implementation for graphIsDirected == false
+template <>
+inline bool Graph::useEdgeInIteration<false>(node u, node v) const {
+    return u >= v;
+}
+
+template <bool graphIsDirected, bool hasWeights, bool graphHasEdgeIds, typename L,
+          bool applyUndirectedFilter>
+inline void Graph::forOutEdgesOfImpl(node u, L handle) const {
+    if (usingCSR) {
+        // CSR-based implementation
+        auto [neighbors, degree] = getCSROutNeighbors(u);
+        if (neighbors == nullptr || degree == 0)
+            return;
+
+        for (count i = 0; i < degree; ++i) {
+            node v = neighbors[i];
+
+            // Apply u>=v deduplication only for full-graph traversals, not forNeighborsOf.
+            if constexpr (!graphIsDirected && applyUndirectedFilter) {
+                if (!useEdgeInIteration<graphIsDirected>(u, v))
+                    continue;
+            }
+
+            edgeweight weight = defaultEdgeWeight;
+            edgeid eid = graphHasEdgeIds ? none : none;
+            edgeLambda(handle, u, v, weight, eid);
+        }
+    } else {
+        // Vector-based graphs should use GraphW
+        // Check exists for mutable graphs
+        if (!exists[u])
+            return;
+        throw std::runtime_error("forOutEdgesOfImpl not supported for vector-based graphs in base "
+                                 "Graph class - use GraphW");
+    }
+}
+
+template <bool graphIsDirected, bool hasWeights, bool graphHasEdgeIds, typename L>
+inline void Graph::forInEdgesOfImpl(node u, L handle) const {
+    if (usingCSR) {
+        // Note: For immutable CSR graphs, all nodes exist so we skip exists check to avoid
+        // thread-safety issues with std::vector<bool> in parallel contexts
+        if constexpr (graphIsDirected) {
+            // For directed graphs, use incoming edges
+            auto [neighbors, degree] = getCSRInNeighbors(u);
+            if (neighbors == nullptr || degree == 0)
+                return;
+
+            for (count i = 0; i < degree; ++i) {
+                node v = neighbors[i];
+                // Skip exists[v] check for CSR graphs - all nodes always exist
+
+                // Get edge weight (currently CSR graphs are unweighted)
+                edgeweight weight = hasWeights ? defaultEdgeWeight : defaultEdgeWeight;
+
+                // Get edge ID (CSR graphs don't currently support edge IDs)
+                edgeid eid = graphHasEdgeIds ? none : none;
+
+                // For incoming edges: u is current node (target), v is neighbor (source)
+                edgeLambda(handle, u, v, weight, eid);
+            }
+        } else {
+            // For undirected graphs, incoming edges are the same as outgoing edges
+            auto [neighbors, degree] = getCSROutNeighbors(u);
+            if (neighbors == nullptr || degree == 0)
+                return;
+
+            for (count i = 0; i < degree; ++i) {
+                node v = neighbors[i];
+                // Skip exists[v] check for CSR graphs - all nodes always exist
+
+                // Get edge weight (currently CSR graphs are unweighted)
+                edgeweight weight = hasWeights ? defaultEdgeWeight : defaultEdgeWeight;
+
+                // Get edge ID (CSR graphs don't currently support edge IDs)
+                edgeid eid = graphHasEdgeIds ? none : none;
+
+                // For undirected graphs, pass (u, v) where u is current node and v is neighbor
+                edgeLambda(handle, u, v, weight, eid);
+            }
+        }
+    } else {
+        // For vector-based graphs (GraphW), use the virtual dispatch
+        // Check exists for mutable graphs
+        if (!exists[u])
+            return;
+        // GraphW's forInEdgesVirtualImpl calls handle(v, u, ...) where v is neighbor and u is
+        // current node We need to swap so that edgeLambda receives (current, neighbor, ...) and
+        // passes neighbor to f
+        forInEdgesVirtualImpl(
+            u, graphIsDirected, hasWeights, graphHasEdgeIds,
+            [&](node v, node u, edgeweight w, edgeid e) { edgeLambda(handle, u, v, w, e); });
+    }
+}
+
+template <bool graphIsDirected, bool hasWeights, bool graphHasEdgeIds, typename L>
+inline void Graph::forEdgeImpl(L handle) const {
+    if (usingCSR) {
+        for (node u = 0; u < z; ++u) {
+            forOutEdgesOfImpl<graphIsDirected, hasWeights, graphHasEdgeIds, L, true>(u, handle);
+        }
+    } else {
+        // For vector-based graphs (GraphW), use the virtual dispatch
+        forEdgesVirtualImpl(
+            graphIsDirected, hasWeights, graphHasEdgeIds,
+            [&](node u, node v, edgeweight w, edgeid e) { edgeLambda(handle, u, v, w, e); });
+    }
+}
+
+template <bool graphIsDirected, bool hasWeights, bool graphHasEdgeIds, typename L>
+inline void Graph::parallelForEdgesImpl(L handle) const {
+    if (usingCSR) {
+#pragma omp parallel for schedule(guided)
+        for (omp_index u = 0; u < static_cast<omp_index>(z); ++u) {
+            forOutEdgesOfImpl<graphIsDirected, hasWeights, graphHasEdgeIds, L, true>(u, handle);
+        }
+    } else {
+        // For vector-based graphs, use the virtual dispatch
+        forEdgesVirtualImpl(
+            graphIsDirected, hasWeights, graphHasEdgeIds,
+            [&](node u, node v, edgeweight w, edgeid e) { edgeLambda(handle, u, v, w, e); });
+    }
+}
+
+template <bool graphIsDirected, bool hasWeights, bool graphHasEdgeIds, typename L>
+inline double Graph::parallelSumForEdgesImpl(L handle) const {
+    double sum = 0.0;
+
+    if (usingCSR) {
+        // CSR-based parallel implementation
+        // Note: For immutable CSR graphs, all nodes exist so we skip exists check to avoid
+        // thread-safety issues with std::vector<bool> in parallel contexts
+#pragma omp parallel for schedule(guided) reduction(+ : sum)
+        for (omp_index u = 0; u < static_cast<omp_index>(z); ++u) {
+            auto [neighbors, degree] = getCSROutNeighbors(u);
+            if (neighbors == nullptr || degree == 0)
+                continue;
+
+            for (count i = 0; i < degree; ++i) {
+                node v = neighbors[i];
+                // Skip exists[v] check for CSR graphs - all nodes always exist
+
+                // For undirected graphs, only process edge if u >= v to avoid duplicates
+                if constexpr (!graphIsDirected) {
+                    if (!useEdgeInIteration<graphIsDirected>(u, v))
+                        continue;
+                }
+
+                edgeweight w = hasWeights ? defaultEdgeWeight : defaultEdgeWeight;
+                edgeid eid = graphHasEdgeIds ? none : none;
+
+                sum += edgeLambda(handle, u, v, w, eid);
+            }
+        }
+    } else {
+        // For vector-based graphs (GraphW), use the virtual dispatch
+        auto wrapper = [&](node u, node v, edgeweight w, edgeid e) -> double {
+            return edgeLambda(handle, u, v, w, e);
+        };
+        return parallelSumForEdgesVirtualImpl(graphIsDirected, hasWeights, graphHasEdgeIds,
+                                              wrapper);
+    }
+
+    return sum;
+}
+
+template <typename L>
+void Graph::forEdges(L handle) const {
+    switch (weighted + 2 * directed + 4 * edgesIndexed) {
+    case 0: // unweighted, undirected, no edgeIds
+        forEdgeImpl<false, false, false, L>(handle);
+        break;
+
+    case 1: // weighted,   undirected, no edgeIds
+        forEdgeImpl<false, true, false, L>(handle);
+        break;
+
+    case 2: // unweighted, directed, no edgeIds
+        forEdgeImpl<true, false, false, L>(handle);
+        break;
+
+    case 3: // weighted, directed, no edgeIds
+        forEdgeImpl<true, true, false, L>(handle);
+        break;
+
+    case 4: // unweighted, undirected, with edgeIds
+        forEdgeImpl<false, false, true, L>(handle);
+        break;
+
+    case 5: // weighted,   undirected, with edgeIds
+        forEdgeImpl<false, true, true, L>(handle);
+        break;
+
+    case 6: // unweighted, directed, with edgeIds
+        forEdgeImpl<true, false, true, L>(handle);
+        break;
+
+    case 7: // weighted,   directed, with edgeIds
+        forEdgeImpl<true, true, true, L>(handle);
+        break;
+    }
+}
+
+template <typename L>
+void Graph::parallelForEdges(L handle) const {
+    switch (weighted + 2 * directed + 4 * edgesIndexed) {
+    case 0: // unweighted, undirected, no edgeIds
+        parallelForEdgesImpl<false, false, false, L>(handle);
+        break;
+
+    case 1: // weighted,   undirected, no edgeIds
+        parallelForEdgesImpl<false, true, false, L>(handle);
+        break;
+
+    case 2: // unweighted, directed, no edgeIds
+        parallelForEdgesImpl<true, false, false, L>(handle);
+        break;
+
+    case 3: // weighted, directed, no edgeIds
+        parallelForEdgesImpl<true, true, false, L>(handle);
+        break;
+
+    case 4: // unweighted, undirected, with edgeIds
+        parallelForEdgesImpl<false, false, true, L>(handle);
+        break;
+
+    case 5: // weighted,   undirected, with edgeIds
+        parallelForEdgesImpl<false, true, true, L>(handle);
+        break;
+
+    case 6: // unweighted, directed, with edgeIds
+        parallelForEdgesImpl<true, false, true, L>(handle);
+        break;
+
+    case 7: // weighted,   directed, with edgeIds
+        parallelForEdgesImpl<true, true, true, L>(handle);
+        break;
+    }
+}
+
+/* NEIGHBORHOOD ITERATORS */
+
+template <typename L>
+void Graph::forNeighborsOf(node u, L handle) const {
+    forEdgesOf(u, handle);
+}
+
+template <typename L>
+void Graph::forEdgesOf(node u, L handle) const {
+    if (usingCSR) {
+        if (directed) {
+            switch (weighted + 2 * edgesIndexed) {
+            case 0: // not weighted, no edge ids
+                forOutEdgesOfImpl<true, false, false, L>(u, handle);
+                break;
+
+            case 1: // weighted, no edge ids
+                forOutEdgesOfImpl<true, true, false, L>(u, handle);
+                break;
+
+            case 2: // not weighted, with edge ids
+                forOutEdgesOfImpl<true, false, true, L>(u, handle);
+                break;
+
+            case 3: // weighted, with edge ids
+                forOutEdgesOfImpl<true, true, true, L>(u, handle);
+                break;
+            }
+        } else {
+            switch (weighted + 2 * edgesIndexed) {
+            case 0: // not weighted, no edge ids
+                forOutEdgesOfImpl<false, false, false, L>(u, handle);
+                break;
+
+            case 1: // weighted, no edge ids
+                forOutEdgesOfImpl<false, true, false, L>(u, handle);
+                break;
+
+            case 2: // not weighted, with edge ids
+                forOutEdgesOfImpl<false, false, true, L>(u, handle);
+                break;
+
+            case 3: // weighted, with edge ids
+                forOutEdgesOfImpl<false, true, true, L>(u, handle);
+                break;
+            }
+        }
+    } else {
+        // For vector-based graphs, use virtual dispatch
+        forEdgesOfVirtualImpl(u, directed, weighted, edgesIndexed,
+                              [&](node uu, node vv, edgeweight ww, edgeid ee) {
+                                  edgeLambda(handle, uu, vv, ww, ee);
+                              });
+    }
+}
+
+template <typename L>
+void Graph::forInNeighborsOf(node u, L handle) const {
+    forInEdgesOf(u, handle);
+}
+
+template <typename L>
+void Graph::forInEdgesOf(node u, L handle) const {
+    switch (weighted + 2 * directed + 4 * edgesIndexed) {
+    case 0: // unweighted, undirected, no edge ids
+        forInEdgesOfImpl<false, false, false, L>(u, handle);
+        break;
+
+    case 1: // weighted, undirected, no edge ids
+        forInEdgesOfImpl<false, true, false, L>(u, handle);
+        break;
+
+    case 2: // unweighted, directed, no edge ids
+        forInEdgesOfImpl<true, false, false, L>(u, handle);
+        break;
+
+    case 3: // weighted, directed, no edge ids
+        forInEdgesOfImpl<true, true, false, L>(u, handle);
+        break;
+
+    case 4: // unweighted, undirected, with edge ids
+        forInEdgesOfImpl<false, false, true, L>(u, handle);
+        break;
+
+    case 5: // weighted, undirected, with edge ids
+        forInEdgesOfImpl<false, true, true, L>(u, handle);
+        break;
+
+    case 6: // unweighted, directed, with edge ids
+        forInEdgesOfImpl<true, false, true, L>(u, handle);
+        break;
+
+    case 7: // weighted, directed, with edge ids
+        forInEdgesOfImpl<true, true, true, L>(u, handle);
+        break;
+    }
+}
+
+/* REDUCTION ITERATORS */
+
+template <typename L>
+double Graph::parallelSumForNodes(L handle) const {
+    double sum = 0.0;
+
+    if (usingCSR) {
+        // For immutable CSR graphs, all nodes exist - skip exists check for thread safety
+#pragma omp parallel for reduction(+ : sum)
+        for (omp_index v = 0; v < static_cast<omp_index>(z); ++v) {
+            sum += handle(v);
+        }
+    } else {
+        // For mutable graphs, check exists
+#pragma omp parallel for reduction(+ : sum)
+        for (omp_index v = 0; v < static_cast<omp_index>(z); ++v) {
+            if (exists[v]) {
+                sum += handle(v);
+            }
+        }
+    }
+
+    return sum;
+}
+
+template <typename L>
+double Graph::parallelSumForEdges(L handle) const {
+    double sum = 0.0;
+
+    switch (weighted + 2 * directed + 4 * edgesIndexed) {
+    case 0: // unweighted, undirected, no edge ids
+        sum = parallelSumForEdgesImpl<false, false, false, L>(handle);
+        break;
+
+    case 1: // weighted,   undirected, no edge ids
+        sum = parallelSumForEdgesImpl<false, true, false, L>(handle);
+        break;
+
+    case 2: // unweighted, directed, no edge ids
+        sum = parallelSumForEdgesImpl<true, false, false, L>(handle);
+        break;
+
+    case 3: // weighted,   directed, no edge ids
+        sum = parallelSumForEdgesImpl<true, true, false, L>(handle);
+        break;
+
+    case 4: // unweighted, undirected, with edge ids
+        sum = parallelSumForEdgesImpl<false, false, true, L>(handle);
+        break;
+
+    case 5: // weighted,   undirected, with edge ids
+        sum = parallelSumForEdgesImpl<false, true, true, L>(handle);
+        break;
+
+    case 6: // unweighted, directed, with edge ids
+        sum = parallelSumForEdgesImpl<true, false, true, L>(handle);
+        break;
+
+    case 7: // weighted,   directed, with edge ids
+        sum = parallelSumForEdgesImpl<true, true, true, L>(handle);
+        break;
+    }
+
+    return sum;
+}
+
+/* EDGE MODIFIERS */
+
+template <typename Condition>
+std::pair<count, count> Graph::removeAdjacentEdges([[maybe_unused]] node u,
+                                                   [[maybe_unused]] Condition condition,
+                                                   [[maybe_unused]] bool edgesIn) {
+    // Base Graph class only supports CSR format and is immutable
+    throw std::runtime_error("removeAdjacentEdges not supported in base Graph class - use GraphW "
+                             "for mutable operations");
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_GRAPH_GRAPH_HPP_