@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/distance/DynSSSP.hpp

@@ -0,0 +1,87 @@
+/*
+ * DynSSSP.hpp
+ *
+ *  Created on: 17.07.2014
+ *      Author: cls, ebergamini
+ */
+
+#ifndef NETWORKIT_DISTANCE_DYN_SSSP_HPP_
+#define NETWORKIT_DISTANCE_DYN_SSSP_HPP_
+
+#include <set>
+
+#include <networkit/base/DynAlgorithm.hpp>
+#include <networkit/distance/SSSP.hpp>
+#include <networkit/dynamics/GraphEvent.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Interface for dynamic single-source shortest path algorithms.
+ */
+class DynSSSP : public SSSP, public DynAlgorithm {
+
+    friend class DynApproxBetweenness;
+
+public:
+    /**
+     * The algorithm computes a dynamic SSSP starting from the specified
+     * source vertex.
+     *
+     * @param	graph		input graph.
+     * @param	source	    source vertex.
+     * @param   storePredecessors   keep track of the lists of predecessors?
+     */
+    DynSSSP(const Graph &G, node source, bool storePredecessors = true, node target = none);
+
+    ~DynSSSP() override = default;
+
+    /**
+     * Returns true or false depending on whether the node previoulsy specified
+     * with setTargetNode has been modified by the udate or not.
+     *
+     * @param batch The batch of edge insertions.
+     */
+    bool modified();
+    /**
+     * Set a target node to be `observed` during the update. If a node t is set as
+     * target before the update, the function modified() will return true or false
+     * depending on whether node t has been modified by the update.
+     *
+     * @param t Node to be `observed`.
+     */
+    void setTargetNode(node t = 0);
+
+    /**
+     * Returns the predecessor nodes of @a t on all shortest paths from source to @a t.
+     * @param t Target node.
+     * @return The predecessors of @a t on all shortest paths from source to @a t.
+     */
+    const std::vector<node> &getPredecessors(node t) const;
+
+protected:
+    bool storePreds = true;
+    bool mod = false;
+    node target;
+};
+
+inline bool DynSSSP::modified() {
+    return mod;
+}
+
+inline void DynSSSP::setTargetNode(const node t) {
+    target = t;
+}
+
+inline const std::vector<node> &DynSSSP::getPredecessors(node t) const {
+    if (!storePreds) {
+        throw std::runtime_error("predecessors have not been stored");
+    }
+    return previous[t];
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DISTANCE_DYN_SSSP_HPP_

package/vendor/include/networkit/distance/Eccentricity.hpp

@@ -0,0 +1,32 @@
+/*
+ * Eccentricity.hpp
+ *
+ *  Created on: 19.02.2014
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_DISTANCE_ECCENTRICITY_HPP_
+#define NETWORKIT_DISTANCE_ECCENTRICITY_HPP_
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * The eccentricity of a node `u` is defined as the distance to the farthest
+ * node from `u`. In other words, it is the longest shortest-path starting from
+ * node `u`.
+ */
+class Eccentricity {
+
+public:
+    /**
+     * @return The farthest node v, and the length of the shortest path to v.
+     */
+    static std::pair<node, count> getValue(const Graph &G, node u);
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DISTANCE_ECCENTRICITY_HPP_

package/vendor/include/networkit/distance/EffectiveDiameter.hpp

@@ -0,0 +1,47 @@
+/*
+ *  EffectiveDiameter.hpp
+ *
+ *  Created on: 16.06.2014
+ *      Author: Marc Nemes
+ */
+
+#ifndef NETWORKIT_DISTANCE_EFFECTIVE_DIAMETER_HPP_
+#define NETWORKIT_DISTANCE_EFFECTIVE_DIAMETER_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ */
+class EffectiveDiameter final : public Algorithm {
+
+public:
+    /**
+     * Computes the effective diameter exactly.
+     * The effective diameter is defined as the number of edges on average to reach \p ratio of all
+     * other nodes.
+     * @param G the given graph
+     * @param ratio the ratio of nodes that should be connected (0,1], default = 0.9
+     */
+    EffectiveDiameter(const Graph &G, double ratio = 0.9);
+
+    void run() override;
+
+    /**
+     * Returns the exact effective diameter of the graph.
+     * @return the exact effective diameter of the graph
+     */
+    double getEffectiveDiameter() const;
+
+private:
+    const Graph *G;
+    const double ratio;
+    double effectiveDiameter;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DISTANCE_EFFECTIVE_DIAMETER_HPP_

package/vendor/include/networkit/distance/EffectiveDiameterApproximation.hpp

@@ -0,0 +1,57 @@
+/*
+ *  EffectiveDiameterApproximation.hpp
+ *
+ *  Created on: 29.03.16
+ *      Author: Maximilian Vogel
+ */
+
+#ifndef NETWORKIT_DISTANCE_EFFECTIVE_DIAMETER_APPROXIMATION_HPP_
+#define NETWORKIT_DISTANCE_EFFECTIVE_DIAMETER_APPROXIMATION_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ */
+class EffectiveDiameterApproximation final : public Algorithm {
+
+public:
+    /**
+     * Approximates the effective diameter of a given graph.
+     * The effective diameter is defined as the number of edges on average to reach \p ratio of all
+     * other nodes. Implementation after the ANF algorithm presented in the paper "A Fast and
+     * Scalable Tool for Data Mining in Massive Graphs"[1]
+     *
+     * [1] by Palmer, Gibbons and Faloutsos which can be found here:
+     * http://www.cs.cmu.edu/~christos/PUBLICATIONS/kdd02-anf.pdf
+     *
+     * @param G the given graph
+     * @param ratio the ratio of nodes that should be connected (0,1]; default = 0.9
+     * @param k the number of parallel approximations to get a more robust result; default = 64
+     * @param r the amount of bits that are added to the length of the bitmask to improve the
+     * accuracy; default = 7
+     */
+    EffectiveDiameterApproximation(const Graph &G, double ratio = 0.9, count k = 64, count r = 7);
+
+    void run() override;
+
+    /**
+     * Returns the exact effective diameter of the graph.
+     * @return the exact effective diameter of the graph
+     */
+    double getEffectiveDiameter() const;
+
+private:
+    const Graph *G;
+    const double ratio;
+    const count k;
+    const count r;
+    double effectiveDiameter;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DISTANCE_EFFECTIVE_DIAMETER_APPROXIMATION_HPP_

package/vendor/include/networkit/distance/FloydWarshall.hpp

@@ -0,0 +1,93 @@
+/*  FloydWarshall.hpp
+ *
+ *	Created on: 15.02.2025
+ *  Authors: Andreas Scharf (andreas.b.scharf@gmail.com)
+ *
+ */
+
+#ifndef NETWORKIT_DISTANCE_FLOYD_WARSHALL_HPP_
+#define NETWORKIT_DISTANCE_FLOYD_WARSHALL_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @class FloydWarshall
+ * @brief Computes all-pairs shortest paths using the Floyd-Warshall algorithm.
+ *
+ * This algorithm finds the shortest paths between all node pairs in a weighted graph,
+ * supporting both directed and undirected graphs. It correctly handles negative edge
+ * weights and detects negative cycles. If multiple shortest paths exist, it returns
+ * one with the fewest nodes.
+ *
+ * The algorithm has a time complexity of O(n³), making it suitable for small to
+ * medium-sized graphs.
+ */
+class FloydWarshall : public Algorithm {
+public:
+    /**
+     * @brief Initializes the Floyd-Warshall algorithm for a given graph.
+     *
+     * The input graph must be weighted and may be either directed or undirected.
+     *
+     * @param G The graph on which shortest paths will be computed.
+     */
+    FloydWarshall(const Graph &G);
+    /**
+     * @brief Runs the Floyd-Warshall algorithm.
+     *
+     * Computes shortest path distances and reconstructs paths between all node pairs.
+     * Also identifies nodes involved in negative cycles.
+     */
+    void run() override;
+
+    /**
+     * @brief Returns the shortest distance between two nodes.
+     *
+     * If no path exists, returns `std::numeric_limits<edgeweight>::max()`.
+     *
+     * @param source The starting node.
+     * @param target The destination node.
+     * @return The shortest path distance from `source` to `target`.
+     */
+    edgeweight getDistance(node source, node target) const;
+    /**
+     * @brief Checks whether a node is part of a negative cycle.
+     *
+     * A node is considered part of a negative cycle if its shortest path distance
+     * to itself is negative.
+     *
+     * @param u The node to check.
+     * @return `true` if the node is in a negative cycle, otherwise `false`.
+     */
+    bool isNodeInNegativeCycle(node u) const;
+
+    /**
+     * @brief Retrieves the shortest path between two nodes.
+     *
+     * Returns a sequence of nodes representing the shortest path from `source` to
+     * `target`. If no path exists, returns an empty vector.
+     *
+     * If multiple shortest paths exist with the same total distance, the function
+     * returns the one with the fewest nodes.
+     *
+     * @param source The starting node.
+     * @param target The destination node.
+     * @return A vector of nodes forming the shortest path.
+     */
+    std::vector<node> getNodesOnShortestPath(node source, node target) const;
+
+private:
+    const Graph *graph;
+    static constexpr edgeweight infiniteDistance = std::numeric_limits<edgeweight>::max();
+    std::vector<std::vector<edgeweight>> distances;
+    std::vector<bool> nodesInNegativeCycle;
+    std::vector<std::vector<node>> pathMatrix;
+    std::vector<std::vector<count>> hops;
+    void tagNegativeCycles();
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_DISTANCE_FLOYD_WARSHALL_HPP_

package/vendor/include/networkit/distance/GraphDistance.hpp

@@ -0,0 +1,49 @@
+/*
+ *  GraphDistance.hpp
+ *
+ *  Created on: Jul 23, 2013
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_DISTANCE_GRAPH_DISTANCE_HPP_
+#define NETWORKIT_DISTANCE_GRAPH_DISTANCE_HPP_
+
+#include <networkit/distance/BFS.hpp>
+#include <networkit/distance/Dijkstra.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+// TODO: inherit from NodeDistance
+/**
+ * @ingroup distance
+ */
+class GraphDistance final {
+public:
+    /** Default destructor */
+    virtual ~GraphDistance() = default;
+
+    /**
+     * Returns the distance between @a u and @a v in Graph @a g i.e., the length of the shortest
+     * path between the two. Zero if u = v, maximal possible value if no path exists.
+     *
+     * @param g The graph.
+     * @param u Endpoint of edge.
+     * @param v Endpoint of edge.
+     * @return The distance between @a u and @a v.
+     */
+    edgeweight weightedDistance(const Graph &g, node u, node v) const;
+
+    /**
+     * Returns the number of edges on shortest unweighted path between @a u and @a v in Graph @a g.
+     *
+     * @param g The graph.
+     * @param u Endpoint of edge.
+     * @param v Endpoint of edge.
+     * @return The number of edges between @a u and @a v.
+     */
+    count unweightedDistance(const Graph &g, node u, node v) const;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_DISTANCE_GRAPH_DISTANCE_HPP_

package/vendor/include/networkit/distance/HopPlotApproximation.hpp

@@ -0,0 +1,62 @@
+/*
+ *  HopPlotApproximation.hpp
+ *
+ *  Created on: 30.03.2016
+ *      Author: Maximilian Vogel
+ */
+
+#ifndef NETWORKIT_DISTANCE_HOP_PLOT_APPROXIMATION_HPP_
+#define NETWORKIT_DISTANCE_HOP_PLOT_APPROXIMATION_HPP_
+
+#include <map>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ */
+class HopPlotApproximation final : public Algorithm {
+
+public:
+    /**
+     * Computes an approximation of the hop-plot of a given graph
+     * The hop-plot is the set of pairs (d, g(g)) for each natural number d
+     * and where g(d) is the fraction of connected node pairs whose shortest connecting path has
+     * length at most d. Implementation after the ANF algorithm presented in the paper "A Fast and
+     * Scalable Tool for Data Mining in Massive Graphs"[1]
+     *
+     * [1] by Palmer, Gibbons and Faloutsos which can be found here:
+     * http://www.cs.cmu.edu/~christos/PUBLICATIONS/kdd02-anf.pdf
+     *
+     * @param G the given graph
+     * @param maxDistance the maximum path length that shall be considered. set 0 for
+     * infinity/diameter of the graph
+     * @param k the number of parallel approximations to get a more robust result; default = 64
+     * @param r the amount of bits that are added to the length of the bitmask to improve the
+     * accuracy; default = 7
+     * @return the approximated hop-plot of the graph
+     */
+    HopPlotApproximation(const Graph &G, count maxDistance = 0, count k = 64, count r = 7);
+
+    void run() override;
+
+    /**
+     * Returns the approximated hop-plot of the graph.
+     * @return the approximated hop-plot of the graph
+     */
+    const std::map<count, double> &getHopPlot() const;
+
+private:
+    const Graph *G;
+    const count maxDistance;
+    const count k;
+    const count r;
+    std::map<count, double> hopPlot;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DISTANCE_HOP_PLOT_APPROXIMATION_HPP_

package/vendor/include/networkit/distance/IncompleteDijkstra.hpp

@@ -0,0 +1,66 @@
+/*
+ * IncompleteDijkstra.hpp
+ *
+ *  Created on: 15.07.2014
+ *      Author: dhoske
+ */
+
+#ifndef NETWORKIT_DISTANCE_INCOMPLETE_DIJKSTRA_HPP_
+#define NETWORKIT_DISTANCE_INCOMPLETE_DIJKSTRA_HPP_
+
+#include <unordered_set>
+#include <vector>
+
+#include <tlx/container/d_ary_addressable_int_heap.hpp>
+
+#include <networkit/auxiliary/PrioQueue.hpp>
+#include <networkit/auxiliary/VectorComparator.hpp>
+#include <networkit/distance/IncompleteSSSP.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Implementation of @a IncompleteSSSP using a normal
+ * Dijkstra with binary heaps.
+ */
+class IncompleteDijkstra : public IncompleteSSSP {
+public:
+    /**
+     * Creates a IncompleteDijkstra instance from the sources in
+     * @a sources (act like a super source) in the graph @a G.
+     * The edges in @a G must have nonnegative weight and @a G should
+     * not be null.
+     *
+     * We also consider the nodes in @a explored to not exist
+     * if @a explored is not null.
+     *
+     * @warning We do not copy @a G or @a explored, but store a
+     * non-owning pointer to them. Otherwise IncompleteDijkstra would not
+     * be more efficient than normal Dijkstra. Thus, @a G and @a explored
+     * must exist at least as long as this IncompleteDijkstra instance.
+     *
+     * @todo This is somewhat ugly, but we do not want introduce a
+     * std::shared_ptr<> since @a G and @a explored could well
+     * be stack allocated.
+     */
+    IncompleteDijkstra(const Graph *G, const std::vector<node> &sources,
+                       const std::unordered_set<node> *explored = nullptr);
+
+    bool hasNext() override;
+    std::pair<node, edgeweight> next() override;
+
+private:
+    // Stored reference to outside data structures
+    const Graph *G;
+    const std::unordered_set<node> *explored;
+
+    std::vector<edgeweight> dists;
+
+    tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<edgeweight>> heap;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_DISTANCE_INCOMPLETE_DIJKSTRA_HPP_

package/vendor/include/networkit/distance/IncompleteSSSP.hpp

@@ -0,0 +1,41 @@
+/*
+ * IncompleteSSSP.hpp
+ *
+ *  Created on: 15.07.2014
+ *      Author: dhoske
+ */
+
+#ifndef NETWORKIT_DISTANCE_INCOMPLETE_SSSP_HPP_
+#define NETWORKIT_DISTANCE_INCOMPLETE_SSSP_HPP_
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Abstract base class for single-source shortest path algorithms that return
+ * the nodes in order of increasing distance from the source and do not
+ * necessarily need to compute all distances.
+ */
+class IncompleteSSSP {
+
+public:
+    /**
+     * Returns whether there is a next-nearest node
+     * or all of the nodes reachable from the source
+     * have already been processed.
+     */
+    virtual bool hasNext() = 0;
+
+    /**
+     * Returns the next-nearest node from the source and its
+     * distance to the source. Should only be called if @a hasNext()
+     * returns true.
+     */
+    virtual std::pair<node, edgeweight> next() = 0;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_DISTANCE_INCOMPLETE_SSSP_HPP_

package/vendor/include/networkit/distance/JaccardDistance.hpp

@@ -0,0 +1,57 @@
+/*
+ * JaccardDistance.hpp
+ *
+ *  Created on: 17.11.2014
+ *      Author: Michael Hamann, Gerd Lindner
+ */
+
+#ifndef NETWORKIT_DISTANCE_JACCARD_DISTANCE_HPP_
+#define NETWORKIT_DISTANCE_JACCARD_DISTANCE_HPP_
+
+#include <networkit/auxiliary/Timer.hpp>
+#include <networkit/distance/NodeDistance.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Jaccard distance assigns a distance value to pairs of nodes
+ * according to the similarity of their neighborhoods. Note that we define the JaccardDistance as
+ * 1-JaccardSimilarity.
+ */
+class JaccardDistance final : public NodeDistance {
+
+public:
+    /**
+     * @param G The graph.
+     * @param triangles Edge attribute containing the number of triangles each edge is contained in.
+     */
+    JaccardDistance(const Graph &G, const std::vector<count> &triangles);
+
+    /**
+     * REQ: Needs to be called before getEdgeScores delivers meaningful results.
+     */
+    void preprocess() override;
+
+    /**
+     * Returns the Jaccard distance between node @a u and node @a v.
+     * @return Jaccard distance between the two nodes.
+     */
+    double distance(node u, node v) override;
+
+    /**
+     * Returns the Jaccard distances between all connected nodes.
+     * @return Vector containing the Jaccard distances between all connected pairs of nodes.
+     */
+    const std::vector<double> &getEdgeScores() const override;
+
+private:
+    const std::vector<count> &triangles;
+    std::vector<double> jDistance; // result vector
+
+    inline double getJaccardDistance(count degU, count degV, count t);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_DISTANCE_JACCARD_DISTANCE_HPP_

package/vendor/include/networkit/distance/MultiTargetBFS.hpp

@@ -0,0 +1,32 @@
+#ifndef NETWORKIT_DISTANCE_MULTI_TARGET_BFS_HPP_
+#define NETWORKIT_DISTANCE_MULTI_TARGET_BFS_HPP_
+
+#include <networkit/distance/STSP.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Computes the shortest-path distance from a single source to multiple targets in unweighted
+ * graphs.
+ */
+class MultiTargetBFS final : public STSP {
+
+public:
+    /**
+     * Creates the MultiTargetBFS class for a graph @a G, source node @a source, and
+     * multiple target nodes.
+     *
+     * @param G The graph.
+     * @param source The source node.
+     * @param targetsFirst,targetsLast Range of target nodes.
+     */
+    template <class InputIt>
+    MultiTargetBFS(const Graph &G, node source, InputIt targetsFirst, InputIt targetsLast)
+        : STSP(G, source, targetsFirst, targetsLast) {}
+
+    void run() override;
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_DISTANCE_MULTI_TARGET_BFS_HPP_

package/vendor/include/networkit/distance/MultiTargetDijkstra.hpp

@@ -0,0 +1,40 @@
+#ifndef NETWORKIT_DISTANCE_MULTI_TARGET_DIJKSTRA_HPP_
+#define NETWORKIT_DISTANCE_MULTI_TARGET_DIJKSTRA_HPP_
+
+#include <networkit/auxiliary/VectorComparator.hpp>
+#include <networkit/distance/STSP.hpp>
+
+#include <tlx/container/d_ary_addressable_int_heap.hpp>
+
+#include <vector>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Computes the shortest-path distance from a single source to multiple targets in weighted graphs.
+ */
+class MultiTargetDijkstra final : public STSP {
+
+public:
+    /**
+     * Creates the MultiTargetDijkstra class for a graph @a G, source node @a source, and
+     * multiple target nodes.
+     *
+     * @param G The graph.
+     * @param source The source node.
+     * @param targetsFirst,targetsLast Range of target nodes.
+     */
+    template <class InputIt>
+    MultiTargetDijkstra(const Graph &G, node source, InputIt targetsFirst, InputIt targetsLast)
+        : STSP(G, source, targetsFirst, targetsLast) {}
+
+    void run() override;
+
+private:
+    std::vector<edgeweight> distFromSource;
+    tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<edgeweight>> heap{distFromSource};
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_DISTANCE_MULTI_TARGET_DIJKSTRA_HPP_