@ladybugmem/icebug 0.1.0 → 0.1.2

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

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

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

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

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

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

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

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

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

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

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

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

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