@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,289 @@
+/*
+ * GraphBuilder.hpp
+ *
+ *  Created on: 15.07.2014
+ *      Author: Marvin Ritter (marvin.ritter@gmail.com)
+ */
+
+#ifndef NETWORKIT_GRAPH_GRAPH_BUILDER_HPP_
+#define NETWORKIT_GRAPH_GRAPH_BUILDER_HPP_
+
+#include <vector>
+
+#include <networkit/Globals.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/*
+ * The GraphBuilder helps to speed up graph generation by minimizing the number
+ * of checks on addEdge/setWeight/increaseWeight. Further more it delays the
+ * construction of some internal data structures of the Graph class until you
+ * call toGraph(). toGraph() can only be called once. In the Graph class for an
+ * edge u -> v, v is stored in the adjacent array of u (first half) and u in the
+ * adjacent array of v (second half). (For directed graphs these might be in and
+ * out adjacent arrays.). So each edge can be seen as a pair of 2 half edges. To
+ * allow optimization and mainly parallelization GraphBuilder lets you add both
+ * half edges yourself. You are responsible for adding both half edges,
+ * otherwise you might end up with an invalid Graph object. As adding the first
+ * half edge of an edge u -> v only requires access to the adjacent array of u,
+ * other threads can add edges a -> b as long as a != u. Some goes for the
+ * methods setWeight and increaseWeight. Note: If you add the first half edge of
+ * u -> v, you can change the weight by calling setWeight(u, v, ew) or
+ * increaseWeight(u, v, ew), but calling setWeight(v, u, ew) or
+ * increaseWeight(v, u, ew) will add the second half edge. GraphBuilder allows
+ * you to be lazy and only add one half of each edge. Calling toGraph with
+ * autoCompleteEdges set to true, will make each half Edge in GraphBuilder to
+ * one full edge in Graph.
+ *
+ * So far I didn't came up with a good parallelization for toGraph, so at some
+ * point I might omit the parallel parameter for toGraph.
+ */
+
+class GraphBuilder {
+    count n;         //!< current number of nodes
+    count selfloops; //!< currently encountered number of self loops
+
+    bool weighted;                  //!< true if the graph will be weighted, false otherwise
+    bool directed;                  //!< true if the graph will be directed, false otherwise
+    bool autoCompleteEdges = false; //!< if set to true, all function calls of addHalfEdge() will
+                                    //!< add both half edges, reducing the time to build
+
+    index indexInOutEdgeArrayPerThread(node u, node v) const;
+
+    index indexInInEdgeArrayPerThread(node u, node v) const;
+
+    //!< only used in parallel graph building
+    struct HalfEdge {
+        node source;
+        node destination;
+        // HalfEdge(node source, node destination);
+        HalfEdge(){};
+        HalfEdge(node source, node destination) : source(source), destination(destination){};
+    };
+
+    std::vector<std::vector<std::vector<HalfEdge>>>
+        outEdgesPerThread; //!< outgoing adjacency list for each thread, where
+                           //!< outEdges[cur_thread][u%max_threads] contains v if the edge (u,v)
+                           //!< exists
+    std::vector<std::vector<std::vector<edgeweight>>>
+        outEdgeWeightsPerThread; //!< corresponding weights (if weighted)
+    std::vector<std::vector<std::vector<HalfEdge>>>
+        inEdgesPerThread; //!< ingoing adjacency list (if directed) for each thread, where
+                          //!< inEdges[cur_thread][u%max_threads] contains v if the edge (u,v)
+                          //!< exists
+    std::vector<std::vector<std::vector<edgeweight>>>
+        inEdgeWeightsPerThread; //!< corresponding weights (if weighted)
+
+public:
+    /**
+     * Creates a new GraphBuilder. GraphBuilder supports the basic methods needed
+     * to create a new graph (addNode, addEdge, setWeight, increaseWeight). It is
+     * designed to be much faster for graph creation, but the speed comes with a
+     * restriction: For undirected graphs GraphBuilder will handle u->v and v->u
+     * as two different edges. Keep that in mind when using setWeight and
+     * increaseWeight. GraphBuilder allows parallelization in a special way. It's
+     * internal data structure saves edges only at the source node. As long as
+     * edges from node u are only added/changed by thread t1, every other thread
+     * can modifier edges not starting in u. addNode is not threadsafe.
+     * @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.
+     * @param autoCompleteEdges If set to @c true, the edges will automatically be added to the
+     * adjacency lists of both nodes (decreases the time to build).
+     */
+    GraphBuilder(count n = 0, bool weighted = false, bool directed = false,
+                 bool autoCompleteEdges = false);
+
+    void reset(count n = 0);
+
+    /**
+     * 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.
+     */
+    inline bool isWeighted() const { return weighted; }
+
+    /**
+     * Return <code>true</code> if this graph supports directed edges.
+     * @return </code>true</code> if this graph supports directed edges.
+     */
+    inline bool isDirected() const { return directed; }
+
+    /**
+     * Return <code>true</code> if graph contains no nodes.
+     * @return <code>true</code> if graph contains no nodes.
+     */
+    inline bool isEmpty() const { return n == 0; }
+
+    /**
+     * Return the number of nodes in the graph.
+     * @return The number of nodes.
+     */
+    count numberOfNodes() const { return n; }
+
+    /**
+     * Get an upper bound for the node ids in the graph.
+     * @return An upper bound for the node ids.
+     */
+    index upperNodeIdBound() const { return n; }
+
+    /**
+     * Add a new node to the graph and return it.
+     * @return The new node.
+     */
+    node addNode();
+
+    /**
+     * Insert an edge between the nodes @a u and @a v. If the graph is weighted
+     * you can optionally set a weight for this edge. The default weight is 1.0.
+     * If setUseWholeEdges(true) has been called prior, this sets both half edges, which improves
+     * the performance of the graph builder.
+     * @param u Endpoint of edge.
+     * @param v Endpoint of edge.
+     * @param weight Optional edge weight.
+     */
+    void addHalfEdge(node u, node v, edgeweight ew = defaultEdgeWeight);
+    void addHalfOutEdge(node u, node v, edgeweight ew = defaultEdgeWeight);
+    void addHalfInEdge(node u, node v, edgeweight ew = defaultEdgeWeight);
+
+    void swapNeighborhood(node u, std::vector<node> &neighbours, std::vector<edgeweight> &weights,
+                          bool selfloop);
+
+    /**
+     * Set the weight of an edge. If the edge does not exist,
+     * it will be inserted.
+     *
+     * @param[in]  u  endpoint of edge
+     * @param[in]  v  endpoint of edge
+     * @param[in]  weight  edge weight
+     */
+    void setWeight(node u, node v, edgeweight ew) { setOutWeight(u, v, ew); }
+    void setOutWeight(node u, node v, edgeweight ew);
+    void setInWeight(node u, node v, edgeweight ew);
+
+    /**
+     * Increase the weight of an edge. If the edge does not exist,
+     * it will be inserted.
+     *
+     * @param[in]  u  endpoint of edge
+     * @param[in]  v  endpoint of edge
+     * @param[in]  ew  edge weight
+     */
+    void increaseWeight(node u, node v, edgeweight ew) { increaseOutWeight(u, v, ew); }
+    void increaseOutWeight(node u, node v, edgeweight ew);
+    void increaseInWeight(node u, node v, edgeweight ew);
+
+    /**
+     * Generates a Graph instance. The graph builder will be resetted at the end.
+     */
+    GraphW completeGraph();
+
+    /**
+     * DEPRECATED: use completeGraph() instead which uses the parallel mode by default (if
+     * possible).
+     */
+    GraphW TLX_DEPRECATED(completeGraph([[maybe_unused]] bool parallel)) {
+        WARN("GraphBuilder::completeGraph(bool parallel) is deprecated, use "
+             "GraphBuilder::completeGraph() instead");
+        return completeGraph();
+    }
+
+    /**
+     * 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 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;
+
+    /*
+     * If set to true, the graph builder automatically adds the second part of the halfEdge when
+     * calling <code>addHalfEdge(u,v)</code>. This enables the graph building process to be more
+     * efficient, while adding the halfEdges takes slightly longer.
+     */
+    void setAutoCompleteEdges(bool completeEdges = false) { autoCompleteEdges = completeEdges; };
+
+private:
+    void toGraphSequential(Graph &G);
+    void toGraphParallel(Graph &G);
+    void addHalfEdgesToGraph(GraphW &G);
+
+    template <typename T>
+    static void copyAndClear(std::vector<T> &source, std::vector<T> &target);
+
+    count numberOfEdges(const Graph &G);
+};
+
+template <typename L>
+void GraphBuilder::forNodes(L handle) const {
+    for (node v = 0; v < n; v++) {
+        handle(v);
+    }
+}
+
+template <typename L>
+void GraphBuilder::parallelForNodes(L handle) const {
+#pragma omp parallel for schedule(dynamic, 100)
+    for (omp_index v = 0; v < static_cast<omp_index>(n); v++) {
+        handle(v);
+    }
+}
+
+template <typename L>
+void GraphBuilder::forNodePairs(L handle) const {
+    for (node u = 0; u < n; u++) {
+        for (node v = u + 1; v < n; v++) {
+            handle(u, v);
+        }
+    }
+}
+
+template <typename L>
+void GraphBuilder::parallelForNodePairs(L handle) const {
+#pragma omp parallel for schedule(dynamic, 100)
+    for (omp_index u = 0; u < static_cast<omp_index>(n); u++) {
+        for (node v = u + 1; v < n; v++) {
+            handle(u, v);
+        }
+    }
+}
+
+template <typename T>
+void GraphBuilder::copyAndClear(std::vector<T> &source, std::vector<T> &target) {
+    std::copy(source.begin(), source.end(), std::back_inserter(target));
+    source.clear();
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_GRAPH_GRAPH_BUILDER_HPP_

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

@@ -0,0 +1,133 @@
+/*
+ * GraphR.hpp
+ *
+ *  Created on: Feb 8, 2026
+ *  Read-only CSR-based graph implementation
+ */
+
+#ifndef NETWORKIT_GRAPH_GRAPH_R_HPP_
+#define NETWORKIT_GRAPH_GRAPH_R_HPP_
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup graph
+ * GraphR - Read-only graph with CSR (Compressed Sparse Row) storage.
+ *
+ * This class provides a memory-efficient, immutable graph representation using
+ * Arrow CSR arrays for zero-copy data sharing. It is optimized for read-only
+ * operations and analysis algorithms.
+ *
+ * For graphs that require mutation (adding/removing nodes or edges), use GraphW instead.
+ */
+class GraphR : public Graph {
+public:
+    /**
+     * 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)
+     */
+    GraphR(count n, bool directed, std::vector<node> outIndices, std::vector<index> outIndptr,
+           std::vector<node> inIndices = {}, std::vector<index> inIndptr = {})
+        : Graph(n, directed, std::move(outIndices), std::move(outIndptr), std::move(inIndices),
+                std::move(inIndptr)) {}
+
+    /**
+     * 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).
+     */
+    GraphR(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)
+        : Graph(n, directed, std::move(outIndices), std::move(outIndptr), std::move(inIndices),
+                std::move(inIndptr), std::move(outWeights), std::move(inWeights)) {}
+
+    /**
+     * Copy constructor
+     */
+    GraphR(const GraphR &other) : Graph(other) {}
+
+    /**
+     * Move constructor
+     */
+    GraphR(GraphR &&other) noexcept : Graph(std::move(other)) {}
+
+    /**
+     * Copy assignment
+     */
+    GraphR &operator=(const GraphR &other) {
+        Graph::operator=(other);
+        return *this;
+    }
+
+    /**
+     * Move assignment
+     */
+    GraphR &operator=(GraphR &&other) noexcept {
+        Graph::operator=(std::move(other));
+        return *this;
+    }
+
+    /** Default destructor */
+    ~GraphR() override = default;
+
+    // Implement pure virtual methods from Graph base class
+
+    count degree(node v) const override;
+    count degreeIn(node v) const override;
+    bool isIsolated(node v) const override;
+
+    /**
+     * Return edge weight of edge {@a u,@a v}. Returns 0 if edge does not
+     * exist. If weights are provided during construction, returns the actual
+     * edge weight; otherwise returns defaultEdgeWeight (1.0).
+     *
+     * @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.
+     */
+    edgeweight weight(node u, node v) const override;
+
+    edgeid edgeId(node u, node v) const override;
+
+    node getIthNeighbor(Unsafe, node u, index i) const override;
+    edgeweight getIthNeighborWeight(node u, index i) const override;
+    node getIthNeighbor(node u, index i) const override;
+    node getIthInNeighbor(node u, index i) const override;
+    std::pair<node, edgeweight> getIthNeighborWithWeight(node u, index i) const override;
+    std::pair<node, edgeid> getIthNeighborWithId(node u, index i) const override;
+
+protected:
+    std::vector<node> getNeighborsVector(node u, bool inEdges = false) const override;
+    std::pair<std::vector<node>, std::vector<edgeweight>>
+    getNeighborsWithWeightsVector(node u, bool inEdges = false) const override;
+
+    index indexInInEdgeArray(node v, node u) const override;
+    index indexInOutEdgeArray(node u, node v) const override;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_GRAPH_GRAPH_R_HPP_