@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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

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

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

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

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