@ladybugmem/icebug 0.1.0 → 0.1.1

package/vendor/include/networkit/components/StronglyConnectedComponents.hpp

@@ -1,50 +0,0 @@
-/*
- * StronglyConnectedComponents.hpp
- *
- *  Created on: 01.06.2014
- *      Authors: Klara Reichard <klara.reichard@gmail.com>
- *               Marvin Ritter <marvin.ritter@gmail.com>
- *               Obada Mahdi <omahdi@gmail.com>
- *               Eugenio Angriman <angrimae@hu-berlin.de>
- */
-
-#ifndef NETWORKIT_COMPONENTS_STRONGLY_CONNECTED_COMPONENTS_HPP_
-#define NETWORKIT_COMPONENTS_STRONGLY_CONNECTED_COMPONENTS_HPP_
-
-#include <networkit/components/ComponentDecomposition.hpp>
-#include <networkit/graph/GraphW.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup components
- */
-class StronglyConnectedComponents final : public ComponentDecomposition {
-
-public:
-    /**
-     * Determines the strongly connected components of a directed graph using Tarjan's algorithm.
-     *
-     * @param G Graph A directed graph.
-     */
-    StronglyConnectedComponents(const Graph &G);
-
-    /**
-     * Runs the algorithm.
-     */
-    void run() override;
-
-    /**
-     * Constructs a new graph that contains only the nodes inside the largest
-     * strongly connected component.
-     * @param G            The input graph.
-     * @param compactGraph If true, the node ids of the output graph will be compacted
-     * (i.e. re-numbered from 0 to n-1). If false, the node ids will not be changed.
-     */
-    static GraphW extractLargestStronglyConnectedComponent(const Graph &G,
-                                                           bool compactGraph = false);
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMPONENTS_STRONGLY_CONNECTED_COMPONENTS_HPP_

package/vendor/include/networkit/components/WeaklyConnectedComponents.hpp

@@ -1,59 +0,0 @@
-/*
- * WeaklyConnectedComponents.hpp
- *
- *  Created on: June 20, 2017
- *      Author: Eugenio Angriman
- */
-
-#ifndef NETWORKIT_COMPONENTS_WEAKLY_CONNECTED_COMPONENTS_HPP_
-#define NETWORKIT_COMPONENTS_WEAKLY_CONNECTED_COMPONENTS_HPP_
-
-#include <memory>
-
-#include <networkit/components/ComponentDecomposition.hpp>
-#include <networkit/graph/GraphW.hpp>
-
-namespace NetworKit {
-
-// pImpl
-namespace ConnectedComponentsDetails {
-template <bool>
-class ConnectedComponentsImpl;
-} // namespace ConnectedComponentsDetails
-
-/**
- * @ingroup components
- * Determines the weakly connected components of a directed graph.
- */
-class WeaklyConnectedComponents final : public ComponentDecomposition {
-public:
-    /**
-     * Create WeaklyConnectedComponents class for Graph @a G.
-     *
-     * @param G The graph.
-     */
-    WeaklyConnectedComponents(const Graph &G);
-
-    ~WeaklyConnectedComponents() override;
-
-    /*
-     * Computes the weakly connected components of the input graph.
-     */
-    void run() override;
-
-    /**
-     * Constructs a new graph that contains only the nodes inside the largest
-     * weakly connected component.
-     * @param G            The input graph.
-     * @param compactGraph If true, the node ids of the output graph will be compacted
-     * (i.e. re-numbered from 0 to n-1). If false, the node ids will not be changed.
-     * @return The largest weakly connected component of the input graph @a G.
-     */
-    static GraphW extractLargestWeaklyConnectedComponent(const Graph &G, bool compactGraph = false);
-
-private:
-    std::unique_ptr<ConnectedComponentsDetails::ConnectedComponentsImpl<true>> impl;
-};
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMPONENTS_WEAKLY_CONNECTED_COMPONENTS_HPP_

package/vendor/include/networkit/correlation/Assortativity.hpp

@@ -1,64 +0,0 @@
-/*
- * Assortativity.hpp
- *
- *  Created on: Jun 13, 2015
- *      Author: Christian Staudt
- */
-
-#ifndef NETWORKIT_CORRELATION_ASSORTATIVITY_HPP_
-#define NETWORKIT_CORRELATION_ASSORTATIVITY_HPP_
-
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/graph/Graph.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup correlation
- *
- * Assortativity computes a coefficient that expresses the correlation of a
- * node attribute among connected pairs of nodes.
- */
-class Assortativity final : public Algorithm {
-
-public:
-    /**
-     * Initialize Assortativity with a graph @a G and an array of numerical
-     * node values.
-     *
-     * @param G The graph.
-     * @param attribute		numerical node value array
-     */
-    Assortativity(const Graph &G, const std::vector<double> &attribute);
-
-    /**
-     * Initialize Assortativity with a graph @a G and a partition of the node set
-     *
-     * @param G The graph.
-     * @param partition		partition of the node set
-     */
-    Assortativity(const Graph &G, const Partition &partition);
-
-    /**
-     * Runs the algorithm. The algorithm is not parallel.
-     */
-    void run() override;
-
-    /**
-     * Return the assortativity coefficient.
-     */
-    double getCoefficient() const;
-
-private:
-    const Graph *G;
-    const std::vector<double> emptyVector;
-    const Partition emptyPartition;
-    const std::vector<double> *attribute;
-    const Partition *partition;
-    bool nominal; // whether we calculate assortativity for a nominal or ordinal attribute
-    double coefficient;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_CORRELATION_ASSORTATIVITY_HPP_

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

@@ -1,70 +0,0 @@
-/*
- * APSP.hpp
- *
- *  Created on: 07.07.2015
- *      Author: Arie Slobbe
- */
-
-#ifndef NETWORKIT_DISTANCE_APSP_HPP_
-#define NETWORKIT_DISTANCE_APSP_HPP_
-
-#include <memory>
-
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/distance/SSSP.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup distance
- * Class for all-pair shortest path algorithm.
- */
-class APSP : public Algorithm {
-
-public:
-    /**
-     * Creates the APSP class for @a G.
-     *
-     * @param G The graph.
-     */
-    APSP(const Graph &G);
-
-    ~APSP() override = default;
-
-    /**
-     * Computes the shortest paths from each node to all other nodes.
-     * The algorithm is parallel.
-     */
-    void run() override;
-
-    /**
-     * Returns a vector of weighted distances between node pairs.
-     *
-     * @return The shortest-path distances from each node to any other node in
-     * the graph.
-     */
-    const std::vector<std::vector<edgeweight>> &getDistances() const {
-        assureFinished();
-        return distances;
-    }
-
-    /**
-     * Returns the distance from u to v or infinity if u and v are not
-     * connected.
-     *
-     */
-    edgeweight getDistance(node u, node v) const {
-        assureFinished();
-        return distances[u][v];
-    }
-
-protected:
-    const Graph &G;
-    std::vector<std::vector<edgeweight>> distances;
-    std::vector<std::unique_ptr<SSSP>> sssps;
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_DISTANCE_APSP_HPP_

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

@@ -1,68 +0,0 @@
-/*
- * AStar.hpp
- *
- *  Created on: 09.08.2019
- *      Author: Eugenio Angriman <angrimae@hu-berlin.de>
- */
-
-#ifndef NETWORKIT_DISTANCE_A_STAR_HPP_
-#define NETWORKIT_DISTANCE_A_STAR_HPP_
-
-#include <networkit/distance/AStarGeneral.hpp>
-
-/**
- * @ingroup distance
- * AStar path-finding algoritm
- */
-namespace NetworKit {
-class AStar final : public STSP {
-public:
-    /**
-     * Creates the AStarGeneral class for the graph @a G, the source node @a
-     * source, and the target node @a target using a template parameter as
-     * heuristic function.
-     *
-     * @param G The graph.
-     * @param distanceHeu Vector with a lower bound of the distance from every
-     * node to the target.
-     * @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.
-     */
-    AStar(const Graph &G, const std::vector<double> &distanceHeu, node source, node target,
-          bool storePred = true)
-        : STSP(G, source, target, storePred),
-          astar(AStarGeneral<Heuristic>(G, Heuristic(distanceHeu), source, target, storePred)) {
-        if (G.upperNodeIdBound() != distanceHeu.size()) {
-            throw std::runtime_error("Error: G.upperNodeIdBound() must be equal to "
-                                     "the size of distanceHeu.");
-        }
-    }
-
-    /*
-     * Executes the AStar algorithm.
-     */
-    void run() override {
-        astar.run();
-        distance = astar.getDistance();
-        hasRun = true;
-    }
-
-    std::vector<node> getPath() const override { return astar.getPath(); }
-
-private:
-    struct Heuristic {
-    public:
-        Heuristic(const std::vector<double> &distanceHeu) : distanceHeu(distanceHeu) {}
-        double operator()(node u) const noexcept { return distanceHeu[u]; }
-
-    private:
-        const std::vector<double> &distanceHeu;
-    };
-
-    AStarGeneral<Heuristic> astar;
-};
-} // namespace NetworKit
-
-#endif // NETWORKIT_DISTANCE_A_STAR_HPP_

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

@@ -1,110 +0,0 @@
-/*
- * AStarGeneral.hpp
- *
- *  Created on: 09.08.2019
- *      Author: Eugenio Angriman <angrimae@hu-berlin.de>
- */
-
-#ifndef NETWORKIT_DISTANCE_A_STAR_GENERAL_HPP_
-#define NETWORKIT_DISTANCE_A_STAR_GENERAL_HPP_
-
-#include <ranges>
-
-#include <networkit/auxiliary/VectorComparator.hpp>
-#include <networkit/distance/STSP.hpp>
-
-#include <tlx/container/d_ary_addressable_int_heap.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup distance
- * AStar path-finding algoritm with general Heuristic function.
- */
-template <typename Heuristic>
-class AStarGeneral final : public STSP {
-public:
-    /**
-     * Creates the AStarGeneral class for the graph @a G, the source node @a
-     * source, and the target node @a target using a template parameter as
-     * heuristic function.
-     *
-     * @param G The graph.
-     * @param heu Heuristic function that takes a node as input and returns a
-     * lower bound of the distance of that node to the target node.
-     * @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.
-     */
-    AStarGeneral(const Graph &G, Heuristic heu, node source, node target, bool storePred = true)
-        : STSP(G, source, target, storePred), heu(heu), heap{prio} {}
-
-    /*
-     * Executes the AStar algorithm.
-     */
-    void run() override {
-        if (source == target) {
-            distance = 0.;
-            hasRun = true;
-            return;
-        }
-
-        init();
-        constexpr auto infdist = std::numeric_limits<edgeweight>::max();
-        const count n = G->upperNodeIdBound();
-        distance = infdist;
-
-        std::ranges::fill(distFromSource, infdist);
-        distFromSource.resize(n, infdist);
-        distFromSource[source] = 0.;
-
-        std::ranges::fill(prio, infdist);
-        prio.resize(n, infdist);
-        prio[source] = 0.;
-
-        heap.clear();
-        heap.reserve(n);
-        heap.push(source);
-
-        node top = none;
-        do {
-            top = heap.extract_top();
-            if (top == target) {
-                distance = distFromSource[target];
-                break;
-            }
-
-            G->forNeighborsOf(top, [&](node u, edgeweight w) {
-                const double newDist = distFromSource[top] + w;
-                if (newDist < distFromSource[u]) {
-                    distFromSource[u] = newDist;
-                    prio[u] = newDist + heu(u);
-                    heap.update(u);
-                    if (storePred) {
-                        pred[u] = top;
-                    }
-                }
-            });
-        } while (!heap.empty());
-
-        if (top != target) {
-            WARN("Source cannot reach target!");
-        } else if (storePred) {
-            buildPath();
-        }
-
-        hasRun = true;
-    }
-
-private:
-    // Priorities used for the heap
-    std::vector<double> distFromSource, prio;
-    // Lower bound of the distance to the target node
-    Heuristic heu;
-
-    tlx::d_ary_addressable_int_heap<node, 2, Aux::LessInVector<double>> heap;
-};
-} // namespace NetworKit
-
-#endif // NETWORKIT_DISTANCE_A_STAR_GENERAL_HPP_

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

@@ -1,52 +0,0 @@
-/*
- * AdamicAdarDistance.hpp
- *
- *  Created on: 18.11.2014
- *      Author: Michael Hamann, Gerd Lindner
- */
-
-#ifndef NETWORKIT_DISTANCE_ADAMIC_ADAR_DISTANCE_HPP_
-#define NETWORKIT_DISTANCE_ADAMIC_ADAR_DISTANCE_HPP_
-
-#include <networkit/distance/NodeDistance.hpp>
-#include <networkit/graph/GraphW.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup distance
- * An implementation of the Adamic Adar distance measure.
- */
-class AdamicAdarDistance final : public NodeDistance {
-
-private:
-    std::vector<double> aaDistance; // result vector
-
-public:
-    /**
-     * @param G The graph.
-     */
-    AdamicAdarDistance(const GraphW &G);
-
-    /**
-     * Computes the Adamic Adar distances of all connected pairs of nodes.
-     * REQ: Needs to be called before distance() and getEdgeScores() deliver meaningful results!
-     */
-    void preprocess() override;
-
-    /**
-     * Returns the Adamic Adar distance between node @a u and node @a v.
-     * @return Adamic Adar distance between the two nodes.
-     */
-    double distance(node u, node v) override;
-
-    /**
-     * Returns the Adamic Adar distances between all connected nodes.
-     * @return Vector containing the Adamic Adar distances between all connected pairs of nodes.
-     */
-    const std::vector<double> &getEdgeScores() const override;
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_DISTANCE_ADAMIC_ADAR_DISTANCE_HPP_

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

@@ -1,130 +0,0 @@
-/*
- * File:   AffectedNodes.hpp
- * Author: paddya
- *
- * Created on 17. Dezember 2016, 16:35
- */
-
-#ifndef NETWORKIT_DISTANCE_AFFECTED_NODES_HPP_
-#define NETWORKIT_DISTANCE_AFFECTED_NODES_HPP_
-
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/dynamics/GraphEvent.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-class AffectedNodes : public Algorithm {
-public:
-    /**
-     * Constructs the AffectedNodes class for a given graph @a G and a graph event
-     * @a event. The run() method computes the set of affected nodes,
-     * their distance to the edge modification and, in the case of an edge insertion,
-     * an upper bound for the improvement of the harmonic closeness centrality
-     * of each affected node.
-     *
-     * @param G The graph.
-     * @param event The graph event.
-     */
-    AffectedNodes(const Graph &G, const GraphEvent &event);
-    /**
-     * Computes the set of affected nodes.
-     */
-    void run() override;
-    /**
-     * Returns the set of affected nodes.
-     *
-     * @return The set of affected nodes
-     */
-    std::vector<node> getNodes();
-    /**
-     * Returns the distances to the edge modification for each node.
-     *
-     * @return The distances to the edge modification for each node
-     */
-    std::vector<edgeweight> getDistances();
-    /**
-     * Returns the level-based improvement bounds for each affected node.
-     *
-     * @return The improvement upper bound for each affected node, indexed by node ID
-     */
-    std::vector<edgeweight> getImprovements();
-
-    edgeweight closenessU = 0;
-    edgeweight closenessV = 0;
-    edgeweight improvementU = 0;
-    edgeweight improvementV = 0;
-
-private:
-    /**
-     * Handles an edge insertion.
-     */
-    void addedEdge();
-    /**
-     * Handles an edge removal.
-     */
-    void removedEdge();
-    /**
-     * Runs a complete BFS from @a source while ignoring the edge between
-     * @a source and @a startNeighbor. This is equivalent to running a
-     * BFS in G $\\setminus$ (source, startNeighbor).
-     *
-     * @param source The source node.
-     * @param startNeighbor The neighbor node to be ignored on level 1.
-     * @return The distances of each node to @a source.
-     */
-    std::vector<edgeweight> bfsWithoutStartNeighbor(node source, node startNeighbor);
-
-    /**
-     * Runs a complete reverse BFS from @a source while ignoring the edge between
-     * @a startNeighbor and @a source. This is equivalent to running a
-     * BFS in G - (source, startNeighbor).
-     *
-     * @param source The source node.
-     * @param startNeighbor The neighbor node to be ignored on level 1.
-     * @return The distances of each node to @a source.
-     */
-    std::vector<edgeweight> reverseBfsWithoutStartNeighbor(node source, node startNeighbor);
-
-    /**
-     * Runs a BFS from @a source while optionally including an edge between
-     * @a source and @a additionalStartNeighbor. This is equivalent to running
-     * a BFS from @a source in  G + (source, additionalStartNeighbor).
-     *
-     * The algorithm prunes a subtree if it encounters a node @a w for which
-     * the new distance is not smaller than the distance in @a distances.
-     *
-     * @param source The source node.
-     * @param distances The distances without the additional edge.
-     * @param additionalStartNeighbor The additional start neighbor.
-     * @return The distances of each node to @a source.
-     */
-    std::pair<std::vector<node>, std::vector<edgeweight>>
-    getAffectedNodes(node source, std::vector<edgeweight> &distances,
-                     node additionalStartNeighbor = none);
-
-    /**
-     * Runs a reverse BFS from @a source while optionally including an edge between
-     * @a additionalStartNeighbor and @a source. This is equivalent to running
-     * a BFS from @a source in  G + (source, additionalStartNeighbor).
-     *
-     * The algorithm prunes a subtree if it encounters a node @a w for which
-     * the new distance is not smaller than the distance in @a distances.
-     *
-     * @param source The source node.
-     * @param distances The distances without the additional edge.
-     * @param additionalStartNeighbor The additional start neighbor.
-     * @return The distances of each node to @a source.
-     */
-    std::pair<std::vector<node>, std::vector<edgeweight>>
-    getAffectedNodesBackwards(node source, std::vector<edgeweight> &distances,
-                              node additionalStartNeighbor = none);
-    const Graph &G;
-    const GraphEvent &event;
-    std::vector<node> nodes;
-    std::vector<edgeweight> distances;
-    std::vector<edgeweight> improvements;
-};
-} // namespace NetworKit
-
-#endif // NETWORKIT_DISTANCE_AFFECTED_NODES_HPP_

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

@@ -1,63 +0,0 @@
-/*
- * AlgebraicDistance.hpp
- *
- *  Created on: 03.11.2015
- *      Author: Henning Meyerhenke, Christian Staudt, Michael Hamann
- */
-
-#ifndef NETWORKIT_DISTANCE_ALGEBRAIC_DISTANCE_HPP_
-#define NETWORKIT_DISTANCE_ALGEBRAIC_DISTANCE_HPP_
-
-#include <networkit/distance/NodeDistance.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup distance
- * Algebraic distance assigns a distance value to pairs of nodes
- * according to their structural closeness in the graph.
- * Algebraic distances will become small within dense subgraphs.
- */
-class AlgebraicDistance final : public NodeDistance {
-
-public:
-    /**
-     * @param G The graph.
-     * @param numberSystems Number of vectors/systems used for algebraic iteration.
-     * @param numberIterations Number of iterations in each system.
-     * @param omega attenuation factor influencing convergence speed.
-     * @param norm The norm factor of the extended algebraic distance.
-     * @param withEdgeScores calculate array of scores for edges {u,v} that equal ad(u,v)
-     */
-    AlgebraicDistance(const Graph &G, count numberSystems = 10, count numberIterations = 30,
-                      double omega = 0.5, index norm = 0, bool withEdgeScores = false);
-
-    void preprocess() override;
-
-    /**
-     * @return algebraic distance between the two nodes.
-     */
-    double distance(node u, node v) override;
-
-    const std::vector<double> &getEdgeScores() const override;
-
-private:
-    /**
-     * initialize vectors randomly
-     */
-    void randomInit();
-
-    count numSystems; //!< number of vectors/systems used for algebraic iteration
-    count numIters;   //!< number of iterations in each system
-    double omega;     //!< attenuation factor influencing the speed of convergence
-    index norm;
-    const index MAX_NORM = 0;
-    bool withEdgeScores;
-
-    std::vector<double> loads; //!< loads[u*numSystems..(u+1)*numSystems]: loads for node u
-
-    std::vector<edgeweight> edgeScores; //!< distance(u,v) for edge {u,v}
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_DISTANCE_ALGEBRAIC_DISTANCE_HPP_