@ladybugmem/icebug 0.1.0 → 0.1.2

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

@@ -1,43 +0,0 @@
-/*
- * BFS.hpp
- *
- *  Created on: Jul 23, 2013
- *      Author: Henning
- */
-
-#ifndef NETWORKIT_DISTANCE_BFS_HPP_
-#define NETWORKIT_DISTANCE_BFS_HPP_
-
-#include <networkit/distance/SSSP.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup distance
- * The BFS class is used to do a breadth-first search on a Graph from a given
- * source node.
- */
-class BFS final : public SSSP {
-
-public:
-    /**
-     * Constructs the BFS 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 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.
-     */
-    BFS(const Graph &G, node source, bool storePaths = true,
-        bool storeNodesSortedByDistance = false, node target = none);
-
-    /**
-     * Breadth-first search from @a source.
-     */
-    void run() override;
-};
-} /* namespace NetworKit */
-#endif // NETWORKIT_DISTANCE_BFS_HPP_

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

@@ -1,51 +0,0 @@
-/*
- * BidirectionalBFS.hpp
- *
- *  Created on: 14.06.2019
- *      Author: Eugenio Angriman <angrimae@hu-berlin.de>
- */
-
-#ifndef NETWORKIT_DISTANCE_BIDIRECTIONAL_BFS_HPP_
-#define NETWORKIT_DISTANCE_BIDIRECTIONAL_BFS_HPP_
-
-#include <queue>
-
-#include <networkit/distance/STSP.hpp>
-
-namespace NetworKit {
-
-/*
- * @ingroup distance
- * Implements a bidirectional breadth-first search on a graph from two given source and target
- * nodes. Explores the graph from both the source and target nodes until the two explorations meet.
- */
-class BidirectionalBFS final : public STSP {
-
-public:
-    /**
-     * Creates the BidirectionalBFS class for a graph @a G, source node @a source, and
-     * target node @a target.
-     *
-     * @param G The graph.
-     * @param source The source node.
-     * @param target The target node.
-     * @param storePred If true, the algorithm will also store the predecessors
-     * and reconstruct a shortest path from @a source and @a target.
-     */
-    BidirectionalBFS(const Graph &G, node source, node target, bool storePred = true)
-        : STSP(G, source, target, storePred) {}
-
-    /*
-     * Perform a bidirectional BFS from the given source and target nodes.
-     */
-    void run() override;
-
-private:
-    std::vector<uint8_t> visited;
-    uint8_t ts = 0;
-    static constexpr uint8_t ballMask = uint8_t(1) << 7;
-    std::queue<node> sQueue, sQueueNext, tQueue, tQueueNext;
-};
-} // namespace NetworKit
-
-#endif // NETWORKIT_DISTANCE_BIDIRECTIONAL_BFS_HPP_

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

@@ -1,69 +0,0 @@
-/*
- * BidirectionalDijkstra.hpp
- *
- *  Created on: 14.06.2019
- *      Author: Eugenio Angriman <angrimae@hu-berlin.de>
- */
-
-#ifndef NETWORKIT_DISTANCE_BIDIRECTIONAL_DIJKSTRA_HPP_
-#define NETWORKIT_DISTANCE_BIDIRECTIONAL_DIJKSTRA_HPP_
-
-#include <networkit/auxiliary/VectorComparator.hpp>
-#include <networkit/distance/STSP.hpp>
-
-#include <tlx/container/d_ary_addressable_int_heap.hpp>
-
-namespace NetworKit {
-
-/*
- * @ingroup distance
- * Bidirectional implementation of the Dijkstra algorithm from two given source and target nodes.
- * Explores the graph from both the source and target nodes until the two explorations meet.
- */
-class BidirectionalDijkstra final : public STSP {
-
-public:
-    /**
-     * Creates the BidirectionalDijkstra class for a graph @a G, source node @a source, and
-     * target node @a target.
-     *
-     * @param G The graph.
-     * @param source The source node.
-     * @param target The target node.
-     * @param storePred If true, the algorithm will also store the predecessors
-     * and reconstruct a shortest path from @a source and @a target.
-     */
-    BidirectionalDijkstra(const Graph &G, node source, node target, bool storePred = true)
-        : STSP(G, source, target, storePred) {}
-
-    /*
-     * Runs the bidirectional Dijkstra algorithm.
-     */
-    void run() override;
-
-private:
-    std::vector<edgeweight> dist1;
-    std::vector<edgeweight> dist2;
-    std::vector<node> predT;
-    std::vector<uint8_t> visited;
-    uint8_t ts = 0;
-    static constexpr uint8_t ballMask = uint8_t(1) << 7;
-
-    void buildPaths(std::stack<std::deque<node>> &pathStack);
-
-    struct CompareST {
-    public:
-        CompareST(const std::vector<edgeweight> &d1, const std::vector<edgeweight> &d2)
-            : d1(d1), d2(d2) {}
-        bool operator()(node u, node v) { return d1[u] + d2[u] < d1[v] + d2[v]; }
-
-    private:
-        const std::vector<edgeweight> &d1, &d2;
-    };
-
-    tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<edgeweight>> h1{dist1};
-    tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<edgeweight>> h2{dist2};
-    tlx::d_ary_addressable_int_heap<node, 2, CompareST> stH{CompareST(dist1, dist2)};
-};
-} // namespace NetworKit
-#endif // NETWORKIT_DISTANCE_BIDIRECTIONAL_DIJKSTRA_HPP_

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

@@ -1,89 +0,0 @@
-/*
- * CommuteTimeDistance.hpp
- *
- *  Created on: 12.04.2016
- *      Author: ebergamini
- */
-
-#ifndef NETWORKIT_DISTANCE_COMMUTE_TIME_DISTANCE_HPP_
-#define NETWORKIT_DISTANCE_COMMUTE_TIME_DISTANCE_HPP_
-
-#include <networkit/algebraic/CSRMatrix.hpp>
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/graph/Graph.hpp>
-#include <networkit/numerics/LAMG/Lamg.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup centrality
- *
- * CommuteTimeDistance edge centrality.
- *
- */
-class CommuteTimeDistance final : public Algorithm {
-
-public:
-    /**
-     * Constructs the CommuteTimeDistance class for the given Graph @a G.
-     * @param G The graph.
-     * @param tol The tolerance used for the approximation
-     */
-    CommuteTimeDistance(const Graph &G, double tol = 0.1);
-
-    /**
-     * Destructor.
-     */
-    ~CommuteTimeDistance() override = default;
-
-    /**
-     * Computes ECTD exactly.
-     */
-    void run() override;
-
-    /**
-     * Computes approximation by projection.
-     */
-    void runApproximation();
-
-    /**
-     * Computes approximation by projection, in parallel.
-     */
-    void runParallelApproximation();
-
-    /**
-     * @return The elapsed time to setup the solver in milliseconds.
-     */
-    uint64_t getSetupTime() const;
-
-    /**
-     * Returns the commute time distance between node @a u and node @a v.
-     * This method does not need the initial preprocessing (no need to call the run() method).
-     * @return commute time distance between the two nodes.
-     */
-
-    double runSinglePair(node u, node v);
-
-    /**
-     * Returns the commute time distance between node @a u and node @a v.
-     * @return commute time distance between the two nodes. Needs to call run() or
-     * runApproximation() first.
-     */
-    double distance(node u, node v);
-
-    double runSingleSource(node u);
-
-protected:
-    const Graph *G;
-    double tol;
-    Lamg<CSRMatrix> lamg;
-    uint64_t setupTime;
-    std::vector<std::vector<double>> distances;
-    std::vector<Vector> solutions;
-    bool exactly;
-    count k;
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_DISTANCE_COMMUTE_TIME_DISTANCE_HPP_

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

@@ -1,97 +0,0 @@
-/*
- * Diameter.hpp
- *
- *  Created on: 19.02.2014
- *      Author: Daniel Hoske, Christian Staudt
- */
-
-#ifndef NETWORKIT_DISTANCE_DIAMETER_HPP_
-#define NETWORKIT_DISTANCE_DIAMETER_HPP_
-
-#include <networkit/auxiliary/SignalHandling.hpp>
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-enum DiameterAlgo {
-    AUTOMATIC,
-    EXACT,
-    ESTIMATED_RANGE,
-    ESTIMATED_SAMPLES,
-    ESTIMATED_PEDANTIC,
-    automatic = AUTOMATIC, // this + following added for backwards compatibility
-    exact = EXACT,
-    estimatedRange = ESTIMATED_RANGE,
-    estimatedSamples = ESTIMATED_SAMPLES,
-    estimatedPedantic = ESTIMATED_PEDANTIC
-};
-
-/**
- * @ingroup distance
- */
-class Diameter final : public Algorithm {
-
-public:
-    Diameter(const Graph &G, DiameterAlgo algo = DiameterAlgo::AUTOMATIC, double error = -1.f,
-             count nSamples = 0);
-
-    void run() override;
-
-    std::pair<count, count> getDiameter() const;
-
-private:
-    const Graph *G;
-    DiameterAlgo algo;
-    double error;
-    count nSamples;
-    std::pair<count, count> diameterBounds;
-
-    /**
-     * Get the estimation of the diameter of the graph @a G. The algorithm is based on the
-     * ExactSumSweep algorithm presented in Michele Borassi, Pierluigi Crescenzi, Michel Habib,
-     * Walter A. Kosters, Andrea Marino, Frank W. Takes, Fast diameter and radius BFS-based
-     * computation in (weakly connected) real-world graphs: With an application to the six degrees
-     * of separation games, Theoretical Computer Science, Volume 586, 27 June 2015, Pages 59-80,
-     * ISSN 0304-3975, http://dx.doi.org/10.1016/j.tcs.2015.02.033.
-     * (http://www.sciencedirect.com/science/article/pii/S0304397515001644)
-     * @param G The graph.
-     * @param error The maximum allowed relative error. Set to 0 for the exact diameter.
-     * @return Pair of lower and upper bound for diameter.
-     */
-    std::pair<edgeweight, edgeweight> estimatedDiameterRange(const Graph &G, double error);
-
-    /**
-     * Get the exact diameter of the graph @a G. The algorithm for unweighted graphs is the same as
-     * the algorithm for the estimated diameter range with error 0.
-     *
-     * @param G The graph.
-     * @return exact diameter of the graph @a G
-     */
-    edgeweight exactDiameter(const Graph &G);
-
-    /**
-     * Get a 2-approximation of the node diameter (unweighted diameter) of @a G.
-     *
-     * @param[in] G        The graph.
-     * @param[in] samples  One sample is enough if the graph is connected. If there
-     *       are multiple connected components, then the number of samples
-     *       must be chosen so that the probability of sampling the component
-     *       with the largest diameter is high.
-     * @return A 2-approximation of the vertex diameter (unweighted diameter) of @a G.
-     */
-    edgeweight estimatedVertexDiameter(const Graph &G, count samples);
-
-    /** @return a 2-approximation of the vertex diameter (unweighted diameter) of @a G.
-            Considers each connected component and returns the maximum diameter.
-     */
-    edgeweight estimatedVertexDiameterPedantic(const Graph &G);
-
-    /** @return a 2-approximation of the vertex diameter (unweighted diameter) of @a G.
-            Considers each connected component and returns the maximum diameter.
-    */
-    edgeweight estimatedVertexDiameterPedantic2(const Graph &G);
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_DISTANCE_DIAMETER_HPP_

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

@@ -1,50 +0,0 @@
-/*
- * Dijkstra.hpp
- *
- *  Created on: Jul 23, 2013
- *      Author: Henning, Christian Staudt
- */
-
-#ifndef NETWORKIT_DISTANCE_DIJKSTRA_HPP_
-#define NETWORKIT_DISTANCE_DIJKSTRA_HPP_
-
-#include <tlx/container/d_ary_addressable_int_heap.hpp>
-
-#include <networkit/auxiliary/VectorComparator.hpp>
-#include <networkit/distance/SSSP.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup distance
- * Dijkstra's SSSP algorithm.
- */
-class Dijkstra final : public SSSP {
-
-public:
-    /**
-     * Creates the Dijkstra class for @a G and the source node @a source.
-     *
-     * @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.
-     */
-    Dijkstra(const Graph &G, node source, bool storePaths = true,
-             bool storeNodesSortedByDistance = false, node target = none);
-
-    /**
-     * Performs the Dijkstra SSSP algorithm on the graph given in the
-     * constructor.
-     */
-    void run() override;
-
-private:
-    tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<double>> heap;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_DISTANCE_DIJKSTRA_HPP_

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

@@ -1,67 +0,0 @@
-/*
- * DynAPSP.hpp
- *
- *  Created on: 12.08.2015
- *      Author: Arie Slobbe, Elisabetta Bergamini
- */
-
-#ifndef NETWORKIT_DISTANCE_DYN_APSP_HPP_
-#define NETWORKIT_DISTANCE_DYN_APSP_HPP_
-
-#include <networkit/base/DynAlgorithm.hpp>
-#include <networkit/distance/APSP.hpp>
-#include <networkit/dynamics/GraphEvent.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup distance
- * Dynamic APSP.
- */
-class DynAPSP : public APSP, public DynAlgorithm {
-
-public:
-    /**
-     * Creates the object for @a G.
-     *
-     * @param G The graph.
-     */
-    DynAPSP(const Graph &G);
-
-    /** initialize distances and Pred by repeatedly running the Dijkstra2 algorithm */
-    void run() override;
-
-    /**
-     * Updates the pairwise distances after an edge insertions on the graph.
-     * Notice: it works only with edge insertions.
-     *
-     * @param e The edge insertions.
-     */
-    void update(GraphEvent e) override;
-
-    /**
-     * Updates the pairwise distances after a batch of edge insertions on the graph.
-     * Notice: it works only with edge insertions.
-     *
-     * @param batch The batch of edge insertions.
-     */
-    void updateBatch(const std::vector<GraphEvent> &batch) override;
-
-    /** Returns number of visited pairs */
-    count visPairs();
-
-    /**
-     * Returns a vector containing a shortest path from node u to node v, and an empty path if u and
-     * v are not connected.
-     *
-     */
-    std::vector<node> getPath(node u, node v);
-
-private:
-private:
-    count visitedPairs = 0;
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_DISTANCE_DYN_APSP_HPP_

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

@@ -1,56 +0,0 @@
-/*
- * DynBFS.hpp
- *
- *  Created on: 17.07.2014
- *      Author: cls, ebergamini
- */
-
-#ifndef NETWORKIT_DISTANCE_DYN_BFS_HPP_
-#define NETWORKIT_DISTANCE_DYN_BFS_HPP_
-
-#include <networkit/distance/DynSSSP.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup distance
- * Dynamic breadth-first search.
- */
-class DynBFS final : public DynSSSP {
-
-    static constexpr edgeweight infDist = std::numeric_limits<edgeweight>::max();
-
-public:
-    /**
-     * Creates the object for @a G and source @a s.
-     *
-     * @param G The graph.
-     * @param s The source node.
-     * @param storePredecessors keep track of the lists of predecessors?
-     */
-    DynBFS(const Graph &G, node s, bool storePredecessors = true);
-
-    void run() override;
-
-    /** Updates the distances after an edge insertion.*/
-    void update(GraphEvent e) override;
-
-    /** Updates the distances after a batch of edge insertions.*/
-    void updateBatch(const std::vector<GraphEvent> &batch) override;
-
-    /* Returns the number of shortest paths to node t.*/
-    bigfloat getNumberOfPaths(node t) const;
-
-private:
-    enum Color { WHITE, BLACK, GRAY };
-    std::vector<Color> color;
-    count maxDistance;
-};
-
-inline bigfloat DynBFS::getNumberOfPaths(node t) const {
-    return npaths[t];
-}
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_DISTANCE_DYN_BFS_HPP_

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

@@ -1,57 +0,0 @@
-/*
- * DynDijkstra.hpp
- *
- *  Created on: 21.07.2014
- *      Author: ebergamini
- */
-
-#ifndef NETWORKIT_DISTANCE_DYN_DIJKSTRA_HPP_
-#define NETWORKIT_DISTANCE_DYN_DIJKSTRA_HPP_
-
-#include <tlx/container/d_ary_addressable_int_heap.hpp>
-
-#include <networkit/auxiliary/VectorComparator.hpp>
-#include <networkit/distance/DynSSSP.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup distance
- * Dynamic Dijkstra.
- */
-class DynDijkstra final : public DynSSSP {
-
-public:
-    /**
-     * Creates the object for @a G and source @a s.
-     *
-     * @param G The graph.
-     * @param s The source node.
-     * @param storePredecessors keep track of the lists of predecessors?
-     */
-    DynDijkstra(const Graph &G, node s, bool storePredecessors = true);
-
-    // TODO the run method could take a vector of distances as an input and in that case just use
-    // those distances instead of computing dijkstra from scratch
-    void run() override;
-
-    /** Updates the distances after an edge insertion.*/
-    void update(GraphEvent e) override;
-
-    /** Updates the distances after a batch of edge insertions.*/
-    void updateBatch(const std::vector<GraphEvent> &batch) override;
-
-private:
-    enum Color { WHITE, GRAY, BLACK };
-    std::vector<Color> color;
-    static constexpr edgeweight infDist = std::numeric_limits<edgeweight>::max();
-    static constexpr edgeweight distEpsilon = 0.000001;
-
-    tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<edgeweight>> heap;
-    std::vector<edgeweight> updateDistances;
-    tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<edgeweight>> updateHeap;
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_DISTANCE_DYN_DIJKSTRA_HPP_

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

@@ -1,67 +0,0 @@
-#ifndef NETWORKIT_DISTANCE_DYN_PRUNED_LANDMARK_LABELING_HPP_
-#define NETWORKIT_DISTANCE_DYN_PRUNED_LANDMARK_LABELING_HPP_
-
-#include <stdexcept>
-#include <vector>
-
-#include <networkit/base/DynAlgorithm.hpp>
-#include <networkit/distance/PrunedLandmarkLabeling.hpp>
-#include <networkit/dynamics/GraphEvent.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup distance
- * Dynamic pruned landmark labeling.
- */
-class DynPrunedLandmarkLabeling final : public PrunedLandmarkLabeling, public DynAlgorithm {
-
-public:
-    /**
-     * Dynamic Pruned Landmark Labeling algorithm based on the paper "Fully Dynamic 2-Hop Cover
-     * Labeling " from D'Angelo et al., ACM JEA 2019. The algorithm computes distance labels by
-     * performing pruned breadth-first searches from each vertex. Distance labels can be updated
-     * efficiently after edge insertions.
-     * @note this algorithm ignores edge weights and only supports edge insertions.
-     *
-     * @param G The input graph.
-     */
-    DynPrunedLandmarkLabeling(const Graph &G) : PrunedLandmarkLabeling(G) {}
-
-    ~DynPrunedLandmarkLabeling() override = default;
-
-    /**
-     * Updates the distance labels after an edge insertion on the graph.
-     * @note supports only edge insertions.
-     *
-     * @param e The edge insertion.
-     */
-    void update(GraphEvent e) override;
-
-    /**
-     * Not implemented. The algorithm does not support batch updates.
-     * @note This function is not implemented.
-     */
-    void updateBatch(const std::vector<GraphEvent> &) override {
-        throw std::runtime_error("Not implemented.");
-    }
-
-private:
-    /**
-     * Updates the distance labels after an edge insertion.
-     * @param u Source node of the edge.
-     * @param v Target node of the edge.
-     */
-    void addEdge(node u, node v);
-
-    void prunedBFS(node k, node startNode, count bfsLevel, bool reverse);
-
-    void sortUpdatedLabels(bool reverse);
-
-    std::vector<node> updatedNodes;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_DISTANCE_DYN_PRUNED_LANDMARK_LABELING_HPP_