@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/community/PartitionIntersection.hpp

@@ -0,0 +1,25 @@
+#ifndef NETWORKIT_COMMUNITY_PARTITION_INTERSECTION_HPP_
+#define NETWORKIT_COMMUNITY_PARTITION_INTERSECTION_HPP_
+
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * Class for calculating the intersection of two partitions, i.e. the clustering with the fewest
+ * clusters such that each cluster is a subset of a cluster in both partitions.
+ */
+class PartitionIntersection final {
+public:
+    /**
+     * Calculate the intersection of two partitions @a zeta and @a eta
+     * @param zeta The first partition
+     * @param eta The second partition
+     * @return The intersection of @a zeta and @a eta
+     */
+    Partition calculate(const Partition &zeta, const Partition &eta);
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_COMMUNITY_PARTITION_INTERSECTION_HPP_

package/vendor/include/networkit/community/QualityMeasure.hpp

@@ -0,0 +1,27 @@
+/*
+ * QualityMeasure.hpp
+ *
+ *  Created on: 10.12.2012
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_COMMUNITY_QUALITY_MEASURE_HPP_
+#define NETWORKIT_COMMUNITY_QUALITY_MEASURE_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * Abstract base class for all clustering quality measures.
+ */
+class QualityMeasure {
+
+public:
+    virtual double getQuality(const Partition &zeta, const Graph &G) = 0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_QUALITY_MEASURE_HPP_

package/vendor/include/networkit/community/SampledGraphStructuralRandMeasure.hpp

@@ -0,0 +1,40 @@
+/*
+ * SampledGraphStructuralRandMeasure.hpp
+ *
+ *  Created on: 01.07.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_COMMUNITY_SAMPLED_GRAPH_STRUCTURAL_RAND_MEASURE_HPP_
+#define NETWORKIT_COMMUNITY_SAMPLED_GRAPH_STRUCTURAL_RAND_MEASURE_HPP_
+
+#include <networkit/community/DissimilarityMeasure.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * The graph-structural Rand measure assigns a similarity value in [0,1]
+ * to two partitions of a graph, by considering connected pairs of nodes.
+ * This implementation approximates the index by sampling.
+ */
+class SampledGraphStructuralRandMeasure final : public DissimilarityMeasure {
+
+public:
+    /**
+     * Constructs the SampledGraphStructuralRandMeasure. A maximum of @a maxSamples samples are
+     * drawn.
+     *
+     * @param maxSamples The amount of samples to draw.
+     */
+    SampledGraphStructuralRandMeasure(count maxSamples);
+
+    double getDissimilarity(const Graph &G, const Partition &first,
+                            const Partition &second) override;
+
+private:
+    count maxSamples;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_SAMPLED_GRAPH_STRUCTURAL_RAND_MEASURE_HPP_

package/vendor/include/networkit/community/SampledNodeStructuralRandMeasure.hpp

@@ -0,0 +1,40 @@
+/*
+ * SampledNodeStructuralRandMeasure.hpp
+ *
+ *  Created on: 01.07.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_COMMUNITY_SAMPLED_NODE_STRUCTURAL_RAND_MEASURE_HPP_
+#define NETWORKIT_COMMUNITY_SAMPLED_NODE_STRUCTURAL_RAND_MEASURE_HPP_
+
+#include <networkit/community/DissimilarityMeasure.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * The node-structural Rand measure assigns a similarity value in [0,1]
+ * to two partitions of a graph, by considering pairs of nodes.
+ * This implementation approximates the index by sampling.
+ */
+class SampledNodeStructuralRandMeasure final : public DissimilarityMeasure {
+
+public:
+    /**
+     * Constructs the SampledNodeStructuralRandMeasure. A maximum of @a maxSamples samples are
+     * drawn.
+     *
+     * @param maxSamples The amount of samples to draw.
+     */
+    SampledNodeStructuralRandMeasure(count maxSamples);
+
+    double getDissimilarity(const Graph &G, const Partition &first,
+                            const Partition &second) override;
+
+private:
+    count maxSamples;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_SAMPLED_NODE_STRUCTURAL_RAND_MEASURE_HPP_

package/vendor/include/networkit/community/StablePartitionNodes.hpp

@@ -0,0 +1,48 @@
+#ifndef NETWORKIT_COMMUNITY_STABLE_PARTITION_NODES_HPP_
+#define NETWORKIT_COMMUNITY_STABLE_PARTITION_NODES_HPP_
+
+#include <networkit/community/LocalPartitionEvaluation.hpp>
+
+namespace NetworKit {
+
+/**
+ * Evaluates how stable a given partition is. A node is considered to be stable if it has strictly
+ * more connections to its own partition than to other partitions. Isolated nodes are considered to
+ * be stable. The value of a cluster is the percentage of stable nodes in the cluster. Larger values
+ * indicate that a clustering is more stable and thus better defined.
+ */
+class StablePartitionNodes final : public LocalPartitionEvaluation {
+public:
+    using LocalPartitionEvaluation::LocalPartitionEvaluation; // inherit constructor
+
+    /**
+     * Execute the algorithm.
+     */
+    void run() override;
+
+    /**
+     * Check if a given node is stable, i.e. more connected to its own partition than to other
+     * partitions.
+     *
+     * @param u The node to check
+     * @return If the node @a u is stable.
+     */
+    bool isStable(node u) const {
+        assureFinished();
+        return static_cast<bool>(stableMarker[u]);
+    };
+
+    /**
+     * If small values are better. Here large values are better.
+     *
+     * @return false.
+     */
+    bool isSmallBetter() const override { return false; }
+
+private:
+    std::vector<uint8_t> stableMarker;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_STABLE_PARTITION_NODES_HPP_

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

@@ -0,0 +1,116 @@
+/*
+ * BiconnectedeComponents.hpp
+ *
+ * Created on: March 2018
+ * 		 Author: Eugenio Angriman
+ */
+
+#ifndef NETWORKIT_COMPONENTS_BICONNECTED_COMPONENTS_HPP_
+#define NETWORKIT_COMPONENTS_BICONNECTED_COMPONENTS_HPP_
+
+#include <map>
+#include <unordered_set>
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/*
+ * @ingroup components
+ * Determines the biconnected components of an undirected graph as defined in
+ * Tarjan, Robert. Depth-First Search and Linear Graph Algorithms. SIAM J.
+ * Comput. Vol 1, No. 2, June 1972.
+ */
+class BiconnectedComponents final : public Algorithm {
+
+public:
+    /*
+     * Creates BiconnectedComponents class for Graph @a G.
+     *
+     * @param G The graph.
+     */
+    BiconnectedComponents(const Graph &G);
+
+    /*
+     * This method determines the biconnected components for the graph given in
+     * the constructor.
+     */
+    void run() override;
+
+    /*
+     *	Get the number of biconnected components.
+     *
+     *	@return The number of biconnected components.
+     */
+    count numberOfComponents() const;
+
+    /*
+     * Get the size of each component.
+     *
+     * @return Map from component index to size.
+     */
+    std::map<count, count> getComponentSizes() const;
+
+    /*
+     * Get the components vector.
+     *
+     * @return Vector of vectors, each component is stored as an (unordered) set
+     * of nodes.
+     */
+    std::vector<std::vector<node>> getComponents() const;
+
+    /*
+     * Get the components that contain node @a u.
+     *
+     * @param u A node.
+     * @return Components that contain node @a u.
+     */
+    const std::unordered_set<node> &getComponentsOfNode(node u) const {
+        assureFinished();
+        return componentsOfNode[u];
+    }
+
+private:
+    void init();
+    void newComponent(std::pair<node, node> e);
+
+    const Graph *G;
+    count n;
+    count idx;
+    count nComp;
+    std::vector<count> level;
+    std::vector<count> lowpt;
+    std::vector<node> parent;
+    std::vector<bool> visited;
+    std::vector<bool> isRoot;
+    std::vector<std::unordered_set<node>> componentsOfNode;
+    std::map<count, count> componentSizes;
+};
+
+inline count BiconnectedComponents::numberOfComponents() const {
+    assureFinished();
+    return nComp;
+}
+
+inline std::map<count, count> BiconnectedComponents::getComponentSizes() const {
+    assureFinished();
+    return componentSizes;
+}
+
+inline std::vector<std::vector<node>> BiconnectedComponents::getComponents() const {
+    assureFinished();
+    std::vector<std::vector<node>> result(nComp);
+
+    node v = 0;
+    for (auto components : componentsOfNode) {
+        for (auto it = components.begin(); it != components.end(); ++it) {
+            result[*it].push_back(v);
+        }
+        ++v;
+    }
+    return result;
+}
+} // namespace NetworKit
+#endif // NETWORKIT_COMPONENTS_BICONNECTED_COMPONENTS_HPP_

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

@@ -0,0 +1,72 @@
+/*
+ * ComponentDecomposition.hpp
+ *
+ *  Created on: 17.12.2020
+ *      Author: cls,
+ *              Eugenio Angriman <angrimae@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_COMPONENTS_COMPONENT_DECOMPOSITION_HPP_
+#define NETWORKIT_COMPONENTS_COMPONENT_DECOMPOSITION_HPP_
+
+#include <map>
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup components
+ * Abstract class for algorithms that compute the components of a graph.
+ */
+class ComponentDecomposition : public Algorithm {
+public:
+    /**
+     * Constructs the ComponentDecomposition class for the given Graph @a G.
+     *
+     * @param G The graph.
+     */
+    ComponentDecomposition(const Graph &G);
+
+    /**
+     * Get the number of connected components.
+     *
+     * @return The number of connected components.
+     */
+    count numberOfComponents() const;
+
+    /**
+     * Get the component in which node @a u is situated.
+     *
+     * @param[in] u The node whose component is asked for.
+     */
+    count componentOfNode(node u) const;
+
+    /**
+     * Get a Partition that represents the components.
+     *
+     * @return A partition representing the found components.
+     */
+    const Partition &getPartition() const;
+
+    /**
+     * Return the map from component to size
+     */
+    std::map<index, count> getComponentSizes() const;
+
+    /**
+     * @return Vector of components, each stored as (unordered) set of nodes.
+     */
+    std::vector<std::vector<node>> getComponents() const;
+
+protected:
+    const Graph *G;
+    Partition component;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMPONENTS_COMPONENT_DECOMPOSITION_HPP_

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

@@ -0,0 +1,55 @@
+/*
+ * ConnectedComponents.hpp
+ *
+ *  Created on: Dec 16, 2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_COMPONENTS_CONNECTED_COMPONENTS_HPP_
+#define NETWORKIT_COMPONENTS_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
+
+class ConnectedComponents final : public ComponentDecomposition {
+public:
+    /* Creates the ConnectedComponents class for graph @G.
+     *
+     * @param G The graph.
+     */
+    ConnectedComponents(const Graph &G);
+
+    ~ConnectedComponents() override;
+
+    /*
+     * Computes the connected components of the input graph.
+     */
+    void run() override;
+
+    /**
+     * Constructs a new graph that contains only the nodes inside the largest
+     * 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 connected component of the input graph @a G.
+     */
+    static GraphW extractLargestConnectedComponent(const Graph &G, bool compactGraph = false);
+
+private:
+    std::unique_ptr<ConnectedComponentsDetails::ConnectedComponentsImpl<false>> impl;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMPONENTS_CONNECTED_COMPONENTS_HPP_

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

@@ -0,0 +1,71 @@
+/*
+ * DynConnectedComponents.hpp
+ *
+ *  Created on: June 2017
+ *      Author: Eugenio Angriman
+ */
+
+#ifndef NETWORKIT_COMPONENTS_DYN_CONNECTED_COMPONENTS_HPP_
+#define NETWORKIT_COMPONENTS_DYN_CONNECTED_COMPONENTS_HPP_
+
+#include <memory>
+#include <vector>
+
+#include <networkit/base/DynAlgorithm.hpp>
+#include <networkit/components/ComponentDecomposition.hpp>
+#include <networkit/dynamics/GraphEvent.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+// pImpl
+namespace DynConnectedComponentsDetails {
+template <bool>
+class DynConnectedComponentsImpl;
+} // namespace DynConnectedComponentsDetails
+
+/**
+ * @ingroup components
+ * Determines and updates the connected components of an undirected graph.
+ */
+class DynConnectedComponents final : public ComponentDecomposition, public DynAlgorithm {
+
+public:
+    /**
+     * Create ConnectedComponents class for Graph @a G.
+     *
+     * @param G The graph.
+     */
+    DynConnectedComponents(const Graph &G);
+
+    ~DynConnectedComponents() override;
+
+    /**
+     * Finds the connected components of the input graph.
+     */
+    void run() override;
+
+    /**
+     * Updates the connected components after an edge insertion or deletion.
+     *
+     * @param[in]	event	The event that happened (edge deletion or
+     * insertion).
+     */
+    void update(GraphEvent e) override;
+
+    /**
+     * Updates the connected components after a batch of edge insertions or
+     * deletions.
+     *
+     * @param[in] batch	A vector that contains a batch of edge insertions or
+     *					deletions.
+     */
+    void updateBatch(const std::vector<GraphEvent> &batch) override;
+
+private:
+    std::unique_ptr<DynConnectedComponentsDetails::DynConnectedComponentsImpl<false>> impl;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMPONENTS_DYN_CONNECTED_COMPONENTS_HPP_

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

@@ -0,0 +1,73 @@
+/*
+ * DynWeaklyConnectedComponents.hpp
+ *
+ *  Created on: June 20, 2017
+ *      Author: Eugenio Angriman
+ */
+
+#ifndef NETWORKIT_COMPONENTS_DYN_WEAKLY_CONNECTED_COMPONENTS_HPP_
+#define NETWORKIT_COMPONENTS_DYN_WEAKLY_CONNECTED_COMPONENTS_HPP_
+
+#include <memory>
+
+#include <networkit/base/DynAlgorithm.hpp>
+#include <networkit/components/ComponentDecomposition.hpp>
+#include <networkit/dynamics/GraphEvent.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+// pImpl
+namespace DynConnectedComponentsDetails {
+template <bool>
+class DynConnectedComponentsImpl;
+} // namespace DynConnectedComponentsDetails
+
+/**
+ * @ingroup components
+ * Determines and updates the weakly connected components of a directed
+ * graph.
+ */
+class DynWeaklyConnectedComponents final : public ComponentDecomposition, public DynAlgorithm {
+
+public:
+    /**
+     * Create DynWeaklyConnectedComponents class for Graph @a G.
+     *
+     * @param G The graph.
+     */
+    DynWeaklyConnectedComponents(const Graph &G);
+
+    ~DynWeaklyConnectedComponents() override;
+
+    /**
+     * This method determines the weakly connected components for the graph
+     * given in the constructor.
+     */
+    void run() override;
+
+    /**
+     * Updates the weakly connected components after an edge insertion or
+     * deletion.
+     *
+     * @param[in]	event	The event that happened (edge insertion
+     *                       or deletion).
+     */
+    void update(GraphEvent event) override;
+
+    /**
+     * Updates the weakly connected components after a batch of edge events
+     * (insertions or deletions).
+     *
+     * @param[in] batch  A vector that contains a batch of edge events
+     *                   (insertions or deletions).
+     */
+    void updateBatch(const std::vector<GraphEvent> &batch) override;
+
+private:
+    std::unique_ptr<DynConnectedComponentsDetails::DynConnectedComponentsImpl<true>> impl;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMPONENTS_DYN_WEAKLY_CONNECTED_COMPONENTS_HPP_

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

@@ -0,0 +1,44 @@
+/*
+ * ConnectedComponents.cpp
+ *
+ *  Created on: Dec 16, 2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_COMPONENTS_PARALLEL_CONNECTED_COMPONENTS_HPP_
+#define NETWORKIT_COMPONENTS_PARALLEL_CONNECTED_COMPONENTS_HPP_
+
+#include <networkit/components/ComponentDecomposition.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup components
+ * Determines the connected components of an undirected graph.
+ */
+class ParallelConnectedComponents final : public ComponentDecomposition {
+public:
+    /**
+     * @param[in] G Graph for which connected components shall be computed.
+     * @param[in] coarsening Specifies whether the main algorithm based on
+     *   label propagation (LP) shall work recursively (true) or not (false) by
+     *   coarsening/contracting an LP-computed clustering. Defaults to true
+     *   since we saw positive effects in terms of running time for many networks.
+     *   Beware of possible memory implications.
+     */
+    ParallelConnectedComponents(const Graph &G, bool coarsening = true);
+
+    /**
+     * This method determines the connected components for the graph g.
+     */
+    void run() override;
+
+private:
+    bool coarsening;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMPONENTS_PARALLEL_CONNECTED_COMPONENTS_HPP_

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

@@ -0,0 +1,36 @@
+/*
+ * RandomSpanningForest.hpp
+ *
+ *  Created on: 06.09.2015
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_COMPONENTS_RANDOM_SPANNING_FOREST_HPP_
+#define NETWORKIT_COMPONENTS_RANDOM_SPANNING_FOREST_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/SpanningForest.hpp>
+
+namespace NetworKit {
+
+/**
+ * Creates a random spanning tree for each connected component.
+ * Time complexity: cover time of G.
+ * @ingroup graph
+ */
+class RandomSpanningForest final : public SpanningForest {
+public:
+    RandomSpanningForest(const Graph &G);
+
+    ~RandomSpanningForest() override = default;
+
+    /**
+     * Computes for each component a random spanning tree.
+     * Uses simple random-walk based algorithm.
+     * Time complexity: cover time of G.
+     */
+    void run() override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMPONENTS_RANDOM_SPANNING_FOREST_HPP_