@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,87 +0,0 @@
-/*
- * 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

@@ -1,32 +0,0 @@
-/*
- * 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

@@ -1,47 +0,0 @@
-/*
- *  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

@@ -1,57 +0,0 @@
-/*
- *  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

@@ -1,93 +0,0 @@
-/*  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

@@ -1,49 +0,0 @@
-/*
- *  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

@@ -1,62 +0,0 @@
-/*
- *  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

@@ -1,66 +0,0 @@
-/*
- * 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

@@ -1,41 +0,0 @@
-/*
- * 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

@@ -1,57 +0,0 @@
-/*
- * 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

@@ -1,32 +0,0 @@
-#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

@@ -1,40 +0,0 @@
-#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_