@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,47 @@
+/*
+ * NeighborhoodFunction.hpp
+ *
+ *  Created on: 30.03.2016
+ *      Author: Maximilian Vogel
+ */
+
+#ifndef NETWORKIT_DISTANCE_NEIGHBORHOOD_FUNCTION_HPP_
+#define NETWORKIT_DISTANCE_NEIGHBORHOOD_FUNCTION_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ */
+class NeighborhoodFunction final : public Algorithm {
+
+public:
+    /**
+     * Computes the neighborhood function exactly.
+     * The neighborhood function N of a graph G for a given distance t is defined
+     * as the number of node pairs (u,v) that can be reached within distance t.
+     *
+     * @param G the given graph
+     * @return the exact effective diameter of the graph
+     */
+    NeighborhoodFunction(const Graph &G);
+
+    void run() override;
+
+    /**
+     * Returns the neighborhood function of the graph.
+     * @return the neighborhood function of the graph
+     */
+    const std::vector<count> &getNeighborhoodFunction() const;
+
+private:
+    const Graph *G;
+    std::vector<count> result;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DISTANCE_NEIGHBORHOOD_FUNCTION_HPP_

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

@@ -0,0 +1,56 @@
+/*
+ * NeighborhoodFunctionApproximation.hpp
+ *
+ *  Created on: 30.03.2016
+ *      Author: Maximilian Vogel
+ */
+
+#ifndef NETWORKIT_DISTANCE_NEIGHBORHOOD_FUNCTION_APPROXIMATION_HPP_
+#define NETWORKIT_DISTANCE_NEIGHBORHOOD_FUNCTION_APPROXIMATION_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ */
+class NeighborhoodFunctionApproximation final : public Algorithm {
+
+public:
+    /**
+     * Computes an approximation of the neighborhood function.
+     * The neighborhood function N of a graph G for a given distance t is defined
+     * as the number of node pairs (u,v) that can be reached within distance t.
+     * 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 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
+     */
+    NeighborhoodFunctionApproximation(const Graph &G, count k = 64, count r = 7);
+
+    void run() override;
+
+    /**
+     * Returns the approximated neighborhood function of the graph.
+     * @return the approximated neighborhood function of the graph
+     */
+    const std::vector<count> &getNeighborhoodFunction() const;
+
+private:
+    const Graph *G;
+    const count k;
+    const count r;
+    std::vector<count> result;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DISTANCE_NEIGHBORHOOD_FUNCTION_APPROXIMATION_HPP_

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

@@ -0,0 +1,56 @@
+/*
+ * NeighborhoodFunctionHeuristic.hpp
+ *
+ *      Author: Maximilian Vogel
+ */
+
+#ifndef NETWORKIT_DISTANCE_NEIGHBORHOOD_FUNCTION_HEURISTIC_HPP_
+#define NETWORKIT_DISTANCE_NEIGHBORHOOD_FUNCTION_HEURISTIC_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ */
+class NeighborhoodFunctionHeuristic final : public Algorithm {
+
+public:
+    enum SelectionStrategy { RANDOM, SPLIT };
+    /**
+     * Computes a heuristic of the neighborhood function.
+     *
+     * The algorithm runs nSamples breadth-first searches and scales the results up to the actual
+     * amount of nodes. Accepted strategies are "split" and "random".
+     *
+     * @param G the given graph
+     * @param nSamples the amount of samples, set to zero for heuristic of max(sqrt(m), 0.15*n)
+     * @param strategy the strategy to select the samples, accepts "random" or "split"
+     */
+    NeighborhoodFunctionHeuristic(const Graph &G, count nSamples = 0,
+                                  SelectionStrategy strategy = SPLIT);
+
+    void run() override;
+
+    /**
+     * Returns the approximated neighborhood function of the graph.
+     * @return the approximated neighborhood function of the graph
+     */
+    const std::vector<count> &getNeighborhoodFunction() const;
+
+private:
+    const Graph *G;
+    const count nSamples;
+    const SelectionStrategy strategy;
+    std::vector<count> result;
+
+    /* selection schemes implemented as private functions */
+    std::vector<node> random(const Graph &G, count nSamples);
+    std::vector<node> split(const Graph &G, count nSamples);
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DISTANCE_NEIGHBORHOOD_FUNCTION_HEURISTIC_HPP_

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

@@ -0,0 +1,54 @@
+/*
+ * NodeDistance.hpp
+ *
+ *  Created on: 18.06.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_DISTANCE_NODE_DISTANCE_HPP_
+#define NETWORKIT_DISTANCE_NODE_DISTANCE_HPP_
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Abstract base class for node distance measures.
+ */
+class NodeDistance {
+
+protected:
+    const Graph *G;
+
+public:
+    /**
+     * Constructs the NodeDistance class for the given Graph @a G.
+     *
+     * @param G The graph.
+     */
+    NodeDistance(const Graph &G) : G(&G) {}
+
+    /** Default destructor */
+    virtual ~NodeDistance() = default;
+
+    /**
+     * Perform preprocessing work. Needs to be called before distances are requested.
+     */
+    virtual void preprocess() = 0;
+
+    /**
+     * Return the distance between two nodes.
+     * The distance must be normed to return a distance between 0 and 1.
+     */
+    virtual double distance(node u, node v) = 0;
+
+    /**
+     * Returns the distances between all connected pairs of nodes.
+     * @return Vector containing the distances between all connected pairs of nodes.
+     */
+    virtual const std::vector<double> &getEdgeScores() const = 0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_DISTANCE_NODE_DISTANCE_HPP_

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

@@ -0,0 +1,76 @@
+#ifndef NETWORKIT_DISTANCE_PRUNED_LANDMARK_LABELING_HPP_
+#define NETWORKIT_DISTANCE_PRUNED_LANDMARK_LABELING_HPP_
+
+#include <utility>
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+class PrunedLandmarkLabeling : public Algorithm {
+
+public:
+    /**
+     * Pruned Landmark Labeling algorithm based on the paper "Fast exact shortest-path distance
+     * queries on large networks by pruned landmark labeling" from Akiba et al., ACM SIGMOD 2013.
+     * The algorithm computes distance labels by performing pruned breadth-first searches from each
+     * vertex. Labels are used to quickly retrieve shortest-path distances between node pairs.
+     * @note this algorithm only works for unweighted graphs.
+     *
+     * @param G The input graph.
+     */
+    PrunedLandmarkLabeling(const Graph &G);
+
+    /**
+     * Computes distance labels. Run this function before calling 'query'.
+     */
+    void run() override;
+
+    /**
+     * Returns the shortest-path distance between the two nodes.
+     *
+     * @param u Source node.
+     * @param v Target node.
+     *
+     * @return The shortest-path distance from @a u to @a v.
+     */
+    count query(node u, node v) const;
+
+protected:
+    count queryImpl(node u, node v, node upperBound = none) const;
+
+    static constexpr count infDist = std::numeric_limits<count>::max();
+
+    struct Label {
+        Label() : node_(none), distance_(infDist) {}
+        Label(node node_, count distance_) : node_(node_), distance_(distance_) {}
+        node node_;
+        count distance_;
+    };
+
+    const Graph *G;
+    std::vector<node> nodesSortedByDegreeDesc;
+    std::vector<bool> visited;
+    std::vector<std::vector<Label>> labelsOut, labelsIn;
+    std::vector<Label> labelsUCopy, labelsVCopy;
+
+    template <bool Reverse = false>
+    void prunedBFS(node root, node rankOfRootNode);
+
+    auto getSourceLabelsIterators(node u, bool reverse = false) const {
+        if (reverse)
+            return std::make_pair(labelsIn[u].begin(), labelsIn[u].end());
+        else
+            return std::make_pair(labelsOut[u].begin(), labelsOut[u].end());
+    }
+
+    auto getTargetLabelsIterators(node u) const {
+        return std::make_pair(labelsOut[u].begin(), labelsOut[u].end());
+    }
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_DISTANCE_PRUNED_LANDMARK_LABELING_HPP_

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

@@ -0,0 +1,46 @@
+/*
+ * ReverseBFS.hpp
+ *
+ *  Created on: Jul 23, 2013
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_DISTANCE_REVERSE_BFS_HPP_
+#define NETWORKIT_DISTANCE_REVERSE_BFS_HPP_
+
+#include <networkit/distance/SSSP.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup graph
+ * The ReverseBFS class is used to do a reverse breadth-first search (following
+ * the incoming edges of a node) on a Graph from a given source node.
+ */
+class ReverseBFS final : public SSSP {
+
+public:
+    /**
+     * Constructs the ReverseBFS class for @a G and source node @a source.
+     *
+     * @param G The graph.
+     * @param source The source node of the breadth-first search.
+     * @param storePaths store paths and number of paths?
+     * @param storeStack maintain a stack of nodes in decreasing order of
+     * distance
+     */
+    ReverseBFS(const Graph &G, node source, bool storePaths = true,
+               bool storeNodesSortedByDistance = false, node target = none);
+
+    /**
+     * Reverse Breadth-first search from @a source.
+     * @return Vector of unweighted distances from node @a source, i.e. the
+     * length (number of edges) of the shortest path from @a source to any other
+     * node.
+     */
+    void run() override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_DISTANCE_REVERSE_BFS_HPP_

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

@@ -0,0 +1,143 @@
+/*
+ * SPSP.hpp
+ *  Created on: 23.10.2020
+ *      Author: Eugenio Angriman <angrimae@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_DISTANCE_SPSP_HPP_
+#define NETWORKIT_DISTANCE_SPSP_HPP_
+
+#include <unordered_map>
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Class for some-pairs shortest path algorithm.
+ */
+class SPSP final : public Algorithm {
+
+public:
+    /**
+     * Creates the SPSP class for @a G.
+     *
+     * @param G The graph.
+     * @param sourcesFirst,sourcesLast Range of the source nodes.
+     */
+    template <class InputIt>
+    explicit SPSP(const Graph &G, InputIt sourcesFirst, InputIt sourcesLast) : G(&G) {
+        setSources(sourcesFirst, sourcesLast);
+    }
+
+    /**
+     * Creates the SPSP class for @a G.
+     *
+     * @param G The graph.
+     * @param sourcesFirst,sourcesLast Range of the source nodes.
+     * @param targetsFirst,targetLast Range of the target nodes.
+     */
+    template <class SourcesInputIt, class TargetsInputIt>
+    explicit SPSP(const Graph &G, SourcesInputIt sourcesFirst, SourcesInputIt sourcesLast,
+                  TargetsInputIt targetsFirst, TargetsInputIt targetsLast)
+        : G(&G) {
+        setSources(sourcesFirst, sourcesLast);
+        setTargets(targetsFirst, targetsLast);
+    }
+
+    /**
+     * Sets the source nodes.
+     *
+     * @param sourcesFirst,sourcesLast Range of the new source nodes.
+     */
+    template <class InputIt>
+    void setSources(InputIt sourcesFirst, InputIt sourcesLast) {
+        initSourcesOrTargets(sources, sourcesFirst, sourcesLast, sourceIdx);
+    }
+
+    /**
+     * Sets the target nodes.
+     *
+     * @param sourcesFirst,sourcesLast Range of the new source nodes.
+     */
+    template <class InputIt>
+    void setTargets(InputIt targetsFirst, InputIt targetsLast) {
+        initSourcesOrTargets(targets, targetsFirst, targetsLast, targetIdx);
+    }
+
+    ~SPSP() override = default;
+
+    /**
+     * Computes the shortest paths from the source nodes to the target nodes using bidirectional
+     * graph explorations. If no targets nodes are provided, the algorithm computes the shortest
+     * paths from each source node to all the other nodes. The algorithm is parallel.
+     */
+    void run() override;
+
+    /**
+     * Returns a vector of weighted distances between all the source nodes to all the other nodes.
+     *
+     * @return The shortest-path distances from the source nodes to any other node in
+     * the graph.
+     */
+    const std::vector<std::vector<edgeweight>> &getDistances() const {
+        assureFinished();
+        return distances;
+    }
+
+    /**
+     * Returns the distance from the source @a u to node @a v or infinity if @a
+     * u cannot reach @a v.
+     *
+     * @param u A source node.
+     * @param v A node.
+     */
+    edgeweight getDistance(node u, node v) const {
+        assureFinished();
+        if (targets.empty())
+            return distances[sourceIdx.at(u)][v];
+        else
+            return distances[sourceIdx.at(u)][targetIdx.at(v)];
+    }
+
+    /**
+     * Returns the <node, index> map from source nodes to their index in the vector
+     * returned by SPSP::getDistances().
+     *
+     * @return Map from source nodes to their index in the vector returned by SPSP::getDistances().
+     */
+    const std::unordered_map<node, index> &getSourceIndexMap() const noexcept { return sourceIdx; }
+
+    /**
+     * Returns the <node, index> map from target nodes to their index in the vector
+     * returned by SPSP::getDistances().
+     *
+     * @return Map from target nodes to their index in the vector returned by SPSP::getDistances().
+     */
+    const std::unordered_map<node, index> &getTargetIndexMap() const noexcept { return targetIdx; }
+
+private:
+    const Graph *G;
+    std::vector<node> sources, targets;
+    std::unordered_map<node, index> sourceIdx, targetIdx;
+    std::vector<std::vector<edgeweight>> distances;
+
+    template <class InputIt>
+    void initSourcesOrTargets(std::vector<node> &vec, InputIt first, InputIt last,
+                              std::unordered_map<node, index> &indices) {
+        vec.assign(first, last);
+        indices.clear();
+        for (index i = 0; i < vec.size(); ++i)
+            indices.emplace(vec[i], i);
+    }
+
+    void runWithTargets();
+    void runWithoutTargets();
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_DISTANCE_SPSP_HPP_

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

@@ -0,0 +1,216 @@
+/*
+ * SSSP.hpp
+ *
+ *  Created on: 15.04.2014
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_DISTANCE_SSSP_HPP_
+#define NETWORKIT_DISTANCE_SSSP_HPP_
+
+#include <set>
+
+#include <networkit/auxiliary/Multiprecision.hpp>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Abstract base class for single-source shortest path algorithms.
+ */
+class SSSP : public Algorithm {
+
+public:
+    /**
+     * Creates the SSSP class for @a G and source @a s.
+     *
+     * @param G The graph.
+     * @param source The source node.
+     * @param storePaths Paths are reconstructable and the number of paths is
+     * stored.
+     * @param storeNodesSortedByDistance Store a vector of nodes ordered in
+     * increasing distance from the source.
+     * @param target The target node.
+     */
+    SSSP(const Graph &G, node source, bool storePaths = true,
+         bool storeNodesSortedByDistance = false, node target = none);
+
+    ~SSSP() override = default;
+
+    /** Computes the shortest paths from the source to all other nodes. */
+    void run() override = 0;
+
+    /**
+     * Returns a vector of weighted distances from the source node, i.e. the
+     * length of the shortest path from the source node to any other node.
+     *
+     * @return The weighted distances from the source node to any other node in
+     * the graph.
+     */
+    const std::vector<edgeweight> &getDistances();
+
+    /**
+     * Returns the distance from the source node to @a t.
+     * @param  t Target node.
+     * @return The distance from source to target node @a t.
+     */
+    edgeweight distance(node t) const;
+
+    /**
+     * Returns the number of shortest paths between the source node and @a t.
+     * @param  t Target node.
+     * @return The number of shortest paths between source and @a t.
+     */
+    bigfloat numberOfPaths(node t) const;
+
+    /**
+     * Returns the number of shortest paths between the source node and @a t
+     * as a double value. Workaround for Cython
+     * @param  t Target node.
+     * @return The number of shortest paths between source and @a t.
+     */
+    double _numberOfPaths(node t) const;
+
+    /**
+     * 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;
+
+    /**
+     * Returns a shortest path from source to @a t and an empty path if source
+     * and @a t are not connected.
+     *
+     * @param t Target node.
+     * @param forward If @c true (default) the path is directed from source to
+     * @a t, otherwise the path is reversed.
+     * @return A shortest path from source to @a t or an empty path.
+     */
+    std::vector<node> getPath(node t, bool forward = true) const;
+
+    /**
+     * Returns all shortest paths from source to @a t and an empty set if source
+     * and @a t are not connected.
+     *
+     * @param t Target node.
+     * @param forward If @c true (default) the path is directed from source to
+     * @a t, otherwise the path is reversed.
+     * @return All shortest paths from source node to target node @a t.
+     */
+    std::set<std::vector<node>> getPaths(node t, bool forward = true) const;
+
+    /* Returns the number of shortest paths to node t.*/
+    bigfloat getNumberOfPaths(node t) const;
+
+    /**
+     * Returns a vector of nodes ordered in increasing distance from the source.
+     *
+     * For this functionality to be available, storeNodesSortedByDistance has
+     * to be set to true in the constructor. There are no guarantees regarding
+     * the ordering of two nodes with the same distance to the source.
+     *
+     * @return vector of nodes ordered in increasing distance from the source
+     */
+    const std::vector<node> &getNodesSortedByDistance() const;
+
+    /**
+     * Returns the number of nodes reached by the source.
+     *
+     * @return Number of nodes reached by the source.
+     */
+    count getReachableNodes() const {
+        assureFinished();
+        return reachedNodes;
+    }
+
+    /**
+     * Sets a new source.
+     *
+     * @param newSource The new source node.
+     */
+    void setSource(node newSource) {
+        if (!G->hasNode(newSource))
+            throw std::runtime_error("Error: node not in the graph.");
+        source = newSource;
+    }
+
+    /**
+     * Sets a new target.
+     */
+    void setTarget(node newTarget) {
+        if (!G->hasNode(newTarget))
+            throw std::runtime_error("Error: node not in the graph.");
+        target = newTarget;
+    }
+
+    /**
+     * Returns the sum of distances from the source node node to the reached
+     * nodes.
+     */
+    double getSumOfDistances() const {
+        assureFinished();
+        return sumDist;
+    }
+
+protected:
+    const Graph *G;
+    node source;
+    node target;
+    double sumDist;
+    count reachedNodes;
+    std::vector<edgeweight> distances;
+    std::vector<std::vector<node>> previous; // predecessors on shortest path
+    std::vector<bigfloat> npaths;
+
+    std::vector<node> nodesSortedByDistance;
+
+    bool storePaths;                 //!< if true, paths are reconstructable and the number of
+                                     //!< paths is stored
+    bool storeNodesSortedByDistance; //!< if true, store a vector of nodes
+                                     //!< ordered in increasing distance from
+                                     //!< the source
+};
+
+inline edgeweight SSSP::distance(node t) const {
+    return distances[t];
+}
+
+inline bigfloat SSSP::numberOfPaths(node t) const {
+    if (!storePaths) {
+        throw std::runtime_error("number of paths have not been stored");
+    }
+    return npaths[t];
+}
+
+inline double SSSP::_numberOfPaths(node t) const {
+    if (!storePaths) {
+        throw std::runtime_error("number of paths have not been stored");
+    }
+    bigfloat limit = std::numeric_limits<double>::max();
+    if (npaths[t] > limit) {
+        throw std::overflow_error("number of paths do not fit into a double");
+    }
+    double res;
+    npaths[t].ToDouble(res);
+    return res;
+}
+
+inline const std::vector<node> &SSSP::getPredecessors(node t) const {
+    if (!storePaths) {
+        throw std::runtime_error("predecessors have not been stored");
+    }
+    return previous[t];
+}
+
+inline bigfloat SSSP::getNumberOfPaths(node t) const {
+    return npaths[t];
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DISTANCE_SSSP_HPP_