@ladybugmem/icebug 0.1.0

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

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

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

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

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

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

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

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

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

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