@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,175 +0,0 @@
-#ifndef NETWORKIT_COMMUNITY_OVERLAPPING_NMI_DISTANCE_HPP_
-#define NETWORKIT_COMMUNITY_OVERLAPPING_NMI_DISTANCE_HPP_
-
-#include <unordered_map>
-
-#include <networkit/auxiliary/HashUtils.hpp>
-#include <networkit/community/DissimilarityMeasure.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * 	Compare two covers using the overlapping normalized mutual information measure. This is a
- * 	dissimilarity measure with a range of [0, 1]. A value of 0 indicates a perfect agreement while
- * 	a 1 indicates complete disagreement.
- *
- * 	For the `MAX` normalization, this is the measure introduced in [NMI13]. Other normalization
- * 	methods result in similar measures.
- *
- * 	Please note that non-overlapping NMIDistance uses another definition of the normalized mutual
- * 	information. See NMIDistance for details on its computation. Both NMIDistance and
- * 	OverlappingNMIDistance can be used with partitions, but produce different values.
- *
- * [NMI13]
- *      McDaid, Aaron F., Derek Greene, and Neil Hurley.
- *      “Normalized Mutual Information to Evaluate Overlapping Community Finding Algorithms.”
- *      ArXiv:1110.2515 [Physics], August 2, 2013. http://arxiv.org/abs/1110.2515.
- */
-class OverlappingNMIDistance final : public DissimilarityMeasure {
-
-public:
-    enum Normalization { MIN, GEOMETRIC_MEAN, ARITHMETIC_MEAN, MAX, JOINT_ENTROPY };
-
-private:
-    Normalization mNormalization{Normalization::MAX};
-
-public:
-    OverlappingNMIDistance() = default;
-
-    explicit OverlappingNMIDistance(Normalization normalization) : mNormalization(normalization) {}
-
-    void setNormalization(Normalization normalization) { mNormalization = normalization; }
-
-    double getDissimilarity(const Graph &G, const Partition &zeta, const Partition &eta) override;
-    double getDissimilarity(const Graph &G, const Cover &zeta, const Cover &eta) override;
-
-private:
-    struct SizesAndIntersections {
-        std::vector<count> sizesX;
-        std::vector<count> sizesY;
-        std::unordered_map<std::pair<index, index>, count, Aux::PairHash> intersectionSizes;
-    };
-
-    /**
-     * Calculating cluster sizes of covers and intersection sizes between two covers.
-     *
-     * @param X
-     * @param Y
-     * @return The cluster and intersection sizes of X and Y.
-     */
-    static SizesAndIntersections
-    calculateClusterAndIntersectionSizes(const Graph &graph, const Cover &X, const Cover &Y);
-
-    /**
-     * Calculates partial entropy.
-     *
-     * $$
-     *   h(w, n) = -w \log_2\left(\frac{w}{n}\right)
-     * $$
-     *
-     * @param w  Number of occurrences.
-     * @param n  Total number of nodes.
-     * @return
-     */
-    static double h(count w, count n);
-
-    /**
-     * Calculates the entropy of a cluster.
-     *
-     * $$
-     *   H(X_i) = h(|\{ u | u \in X_i \}, n) + h(\{ u | u \notin X_i \}, n)
-     * $$
-     *
-     * @param size  Cluster size.
-     * @param n  Total number of nodes.
-     * @return
-     */
-    static double entropy(count size, count n);
-
-    /**
-     * Calculates the entropy of a clustering.
-     *
-     * $$
-     *   H(X) = \sum_{X_i \in X} H(X_i)
-     * $$
-     *
-     * @param sizesX  The sizes of the clusters in X.
-     * @param n  Total number of nodes.
-     * @return
-     */
-    static double entropy(const std::vector<count> &sizesX, count n);
-
-    /**
-     * Calculates the adjusted conditional entropy between two clusters.
-     *
-     * $$
-     *   H^*(X_i|Y_j) =
-     *   \begin{cases}
-     *       H(X_i|Y_j), & \text{if $h(a, n) + h(d, n) \geq h(b, n) + h(c, n)$}\\
-     *       H(X_i), & \text{otherwise}
-     *   \end{cases}
-     * $$
-     * where
-     * $$
-     *   H(X_i|Y_j) &= H(X_i, Y_j) - H(Y_j)\\
-     *       &= h(a, n) + h(b, n) + h(c, n) + h(d, n) - h(b + d, n) - h(a + c, n),
-     * $$
-     * $a = \sum_u \[X_{i,u} = 0 and Y_{j,u} = 0\]$, $b = \sum_u \[X_{i,u} = 0 and Y_{j,u} = 1\]$,
-     * $c = \sum_u \[X_{i,u} = 1 and Y_{j,u} = 0\]$ and $d = \sum_u \[X_{i,u} = 1 and Y_{j,u} =
-     * 1\]$.
-     *
-     * @param sizeXi  Size of cluster X_i.
-     * @param sizeYj  Size of cluster Y_j.
-     * @param intersectionSize  Size of the intersection of X_i and Y_j.
-     * @param n  Total number of nodes.
-     * @return
-     */
-    static double adjustedConditionalEntropy(count sizeXi, count sizeYj, count intersectionSize,
-                                             count n);
-
-    /**
-     * Calculates the entropy of the clustering X conditioned by the clustering Y.
-     *
-     * $$
-     *   H(X|Y) = \sum_{X_i \in X} \min_{Y_j \in Y} H^*(X_i|Y_j)
-     * $$
-     *
-     * @param sizesX
-     * @param sizesY
-     * @param intersectionSizes
-     *      A map which stores the the intersection size between clusters X[i] and Y[j] with indices
-     * i and j as keys.
-     * @param invertPairIndices
-     *      Whether to invert the indices of the intersectionSizes map entries.
-     *      This allows reusing the same map for H(X|Y) and H(Y|X).
-     * @param n  Total number of nodes.
-     * @return
-     */
-    static double conditionalEntropy(
-        const std::vector<count> &sizesX, const std::vector<count> &sizesY,
-        const std::unordered_map<std::pair<index, index>, count, Aux::PairHash> &intersectionSizes,
-        bool invertPairIndices, count n);
-
-    static void clampBelow(double &value, double lowerBound, const char *format,
-                           int printPrecision = 20);
-
-    static void clampAbove(double &value, double upperBound, const char *format,
-                           int printPrecision = 20);
-
-    /**
-     * Normalize the given mutual information value.
-     *
-     * @param normalization
-     * @param mutualInformation
-     * @param entropyX
-     * @param entropyY
-     * @return
-     */
-    static double normalize(OverlappingNMIDistance::Normalization normalization,
-                            double mutualInformation, double entropyX, double entropyY);
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_OVERLAPPING_NMI_DISTANCE_HPP_

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

@@ -1,89 +0,0 @@
-/*
- * PLM.hpp
- *
- *  Created on: 20.11.2013
- *      Author: cls
- */
-
-#ifndef NETWORKIT_COMMUNITY_PLM_HPP_
-#define NETWORKIT_COMMUNITY_PLM_HPP_
-
-#include <networkit/community/CommunityDetectionAlgorithm.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * Parallel Louvain Method - a multi-level modularity maximizer.
- */
-class PLM final : public CommunityDetectionAlgorithm {
-
-public:
-    /**
-     * @param[in] G input graph
-     * @param[in] refine add a second move phase to refine the communities
-     * @param[in] par parallelization strategy
-     * @param[in] gammamulti-resolution modularity parameter:
-     *            1.0 -> standard modularity
-     *            0.0 -> one community
-     *            2m -> singleton communities
-     * @param[in] maxIter maximum number of iterations for move phase
-     * @param[in] parallelCoarsening use parallel graph coarsening
-     * @param[in] turbo faster but uses O(n) additional memory per thread
-     * @param[in] recurse use recursive coarsening, see
-     * http://journals.aps.org/pre/abstract/10.1103/PhysRevE.89.049902 for some explanations
-     * (default: true)
-     *
-     */
-    PLM(const Graph &G, bool refine = false, double gamma = 1.0, std::string par = "balanced",
-        count maxIter = 32, bool turbo = true, bool recurse = true);
-
-    PLM(const Graph &G, const PLM &other);
-
-    /**
-     * Detect communities.
-     */
-    void run() override;
-
-    /**
-     * Coarsens a graph based on a given partition and returns both the coarsened graph and a
-     * mapping for the nodes from fine to coarse.
-     *
-     * @param graph The input graph
-     * @param zeta Partition of the graph, which represents the desired state of the coarsened graph
-     * @return pair of coarsened graph and node-mappings from fine to coarse graph
-     */
-    static std::pair<GraphW, std::vector<node>> coarsen(const Graph &G, const Partition &zeta);
-
-    /**
-     * Calculates a partition containing the mapping of node-id from a fine graph
-     * to a cluster-id from partition based on a coarse graph.
-     *
-     * @param Gcoarse Coarsened graph
-     * @param zetaCoarse Partition, which contains information about clusters in the coarsened graph
-     * @param Gfine Fine graph
-     * @param nodeToMetaNode mapping for node-id from fine to coarse graph
-     * @return Partition, which contains the cluster-id in the coarse graph for every node from the
-     * fine graph
-     */
-    static Partition prolong(const Graph &Gcoarse, const Partition &zetaCoarse, const Graph &Gfine,
-                             std::vector<node> nodeToMetaNode);
-
-    /**
-     * Returns fine-grained running time measurements for algorithm engineering purposes.
-     */
-    const std::map<std::string, std::vector<count>> &getTiming() const;
-
-private:
-    std::string parallelism;
-    bool refine;
-    double gamma = 1.0;
-    count maxIter;
-    bool turbo;
-    bool recurse;
-    std::map<std::string, std::vector<count>> timing; // fine-grained running time measurement
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_COMMUNITY_PLM_HPP_

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

@@ -1,83 +0,0 @@
-/*
- * PLP.hpp
- *
- *  Created on: 07.12.2012
- *      Author: Christian Staudt
- */
-
-#ifndef NETWORKIT_COMMUNITY_PLP_HPP_
-#define NETWORKIT_COMMUNITY_PLP_HPP_
-
-#include <networkit/community/CommunityDetectionAlgorithm.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * As described in Ovelgoenne et al: An Ensemble Learning Strategy for Graph Clustering
- * Raghavan et al. proposed a label propagation algorithm for graph clustering.
- * This algorithm initializes every vertex of a graph with a unique label. Then, in iterative
- * sweeps over the set of vertices the vertex labels are updated. A vertex gets the label
- * that the maximum number of its neighbors have. The procedure is stopped when every vertex
- * has the label that at least half of its neighbors have.
- *
- */
-class PLP final : public CommunityDetectionAlgorithm {
-
-private:
-    count updateThreshold = 0;
-    count maxIterations;
-    count nIterations = 0;     //!< number of iterations in last run
-    std::vector<count> timing; //!< running times for each iteration
-
-public:
-    /**
-     * Constructor to the label propagation community detection algorithm.
-     *
-     * @param[in] G input graph
-     * @param[in] theta updateThreshold: number of nodes that have to be changed in each iteration
-     * so that a new iteration starts.
-     */
-    PLP(const Graph &G, count theta = none, count maxIterations = none);
-
-    /**
-     * Constructor to the label propagation community detection algorithm.
-     *
-     * @param[in] G input graph
-     * @param[in] baseClustering optional; the algorithm will start from the given clustering.
-     * @param[in] theta updateThreshold: number of nodes that have to be changed in each iteration
-     * so that a new iteration starts.
-     */
-    PLP(const Graph &G, const Partition &baseClustering, count theta = none);
-
-    /**
-     * Run the label propagation clustering algorithm.
-     */
-    void run() override;
-
-    /**
-     * The algorithm runs until a number of nodes less than
-     * the threshold is updated.
-     *
-     * @param th The threshold.
-     */
-    void setUpdateThreshold(count th);
-
-    /**
-     * Get number of iterations in last run.
-     *
-     * @return The number of iterations.
-     */
-    count numberOfIterations();
-
-    /**
-     * Get list of running times for each iteration.
-     *
-     * @return The list of running times in milliseconds
-     */
-    const std::vector<count> &getTiming() const;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_COMMUNITY_PLP_HPP_

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

@@ -1,37 +0,0 @@
-/*
- * ParallelAgglomerativeClusterer.hpp
- *
- *  Created on: 30.10.2012
- *      Author: Christian Staudt, Henning Meyerhenke
- */
-
-#ifndef NETWORKIT_COMMUNITY_PARALLEL_AGGLOMERATIVE_CLUSTERER_HPP_
-#define NETWORKIT_COMMUNITY_PARALLEL_AGGLOMERATIVE_CLUSTERER_HPP_
-
-#include <networkit/community/CommunityDetectionAlgorithm.hpp>
-#include <networkit/graph/GraphW.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * A parallel agglomerative community detection algorithm, maximizing modularity.
- */
-class ParallelAgglomerativeClusterer final : public CommunityDetectionAlgorithm {
-
-public:
-    /**
-     * Constructor to the parallel agglomerative clusterer.
-     *
-     * @param[in] G input graph
-     */
-    ParallelAgglomerativeClusterer(const Graph &G);
-
-    /**
-     * Detect communities.
-     */
-    void run() override;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_COMMUNITY_PARALLEL_AGGLOMERATIVE_CLUSTERER_HPP_

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

@@ -1,96 +0,0 @@
-#ifndef NETWORKIT_COMMUNITY_PARALLEL_LEIDEN_HPP_
-#define NETWORKIT_COMMUNITY_PARALLEL_LEIDEN_HPP_
-
-#include <atomic>
-#include <condition_variable>
-#include <iomanip>
-#include <iostream>
-#include <mutex>
-#include <omp.h>
-#include <thread>
-#include <tlx/unused.hpp>
-#include <networkit/Globals.hpp>
-#include <networkit/auxiliary/Parallel.hpp>
-#include <networkit/auxiliary/Parallelism.hpp>
-#include <networkit/auxiliary/SignalHandling.hpp>
-#include <networkit/auxiliary/Timer.hpp>
-#include <networkit/coarsening/ParallelPartitionCoarsening.hpp>
-#include <networkit/community/CommunityDetectionAlgorithm.hpp>
-#include <networkit/community/Modularity.hpp>
-#include <networkit/community/PLM.hpp>
-#include <networkit/graph/Graph.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-class ParallelLeiden final : public CommunityDetectionAlgorithm {
-public:
-    /**
-     * @note As reported by Sahu et. al in "GVE-Leiden: Fast Leiden Algorithm for Community
-     * Detection in Shared Memory Setting", the current implementation in NetworKit might create a
-     * small fraction of disconnected communities. Since this violates the guarantees from the
-     * original algorithm, ParallelLeiden should be used with caution. In addition the modularity
-     * value of the resulting partition / clustering can be lower compared to other Leiden
-     * implementations and even Louvain.
-     *
-     * @param graph A networkit graph
-     * @param iterations Number of Leiden Iterations to be run
-     * @param randomize Randomize node order?
-     * @param gamma Resolution parameter
-     */
-    explicit ParallelLeiden(const Graph &graph, int iterations = 3, bool randomize = true,
-                            double gamma = 1);
-
-    void run() override;
-
-    int VECTOR_OVERSIZE = 10000;
-
-private:
-    inline double modularityDelta(double cutD, double degreeV, double volD) const {
-        return cutD - gamma * degreeV * volD * inverseGraphVolume;
-    };
-
-    inline double modularityThreshold(double cutC, double volC, double degreeV) const {
-        return cutC - gamma * (volC - degreeV) * degreeV * inverseGraphVolume;
-    }
-
-    static inline void lockLowerFirst(index a, index b, std::vector<std::mutex> &locks) {
-        if (a < b) {
-            locks[a].lock();
-            locks[b].lock();
-        } else {
-            locks[b].lock();
-            locks[a].lock();
-        }
-    }
-
-    void flattenPartition();
-
-    void calculateVolumes(const Graph &graph);
-
-    void parallelMove(const Graph &graph);
-
-    Partition parallelRefine(const Graph &graph);
-
-    double inverseGraphVolume; // 1/vol(V)
-
-    std::vector<double> communityVolumes;
-
-    std::vector<std::vector<node>> mappings;
-
-    static constexpr int WORKING_SIZE = 1000;
-
-    double gamma; // Resolution parameter
-
-    bool changed;
-
-    int numberOfIterations;
-
-    Aux::SignalHandler handler;
-
-    bool random;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_PARALLEL_LEIDEN_HPP_

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

@@ -1,138 +0,0 @@
-/*
- * ParallelLeidenView.hpp
- *
- *  Memory-efficient version of ParallelLeiden using CoarsenedGraphView
- */
-
-#ifndef NETWORKIT_COMMUNITY_PARALLEL_LEIDEN_VIEW_HPP_
-#define NETWORKIT_COMMUNITY_PARALLEL_LEIDEN_VIEW_HPP_
-
-#include <atomic>
-#include <condition_variable>
-#include <iomanip>
-#include <iostream>
-#include <limits>
-#include <memory>
-#include <mutex>
-#include <omp.h>
-#include <thread>
-#include <tlx/unused.hpp>
-#include <networkit/Globals.hpp>
-#include <networkit/auxiliary/Parallel.hpp>
-#include <networkit/auxiliary/Parallelism.hpp>
-#include <networkit/auxiliary/SignalHandling.hpp>
-#include <networkit/auxiliary/Timer.hpp>
-#include <networkit/coarsening/CoarsenedGraphView.hpp>
-#include <networkit/coarsening/ParallelPartitionCoarseningView.hpp>
-#include <networkit/community/CommunityDetectionAlgorithm.hpp>
-#include <networkit/community/Modularity.hpp>
-#include <networkit/community/PLM.hpp>
-#include <networkit/graph/Graph.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-/**
- * Memory-efficient version of ParallelLeiden that uses CoarsenedGraphView
- * instead of creating new graph structures, significantly reducing memory usage
- * during the coarsening process.
- */
-class ParallelLeidenView final : public CommunityDetectionAlgorithm {
-public:
-    /**
-     * @note As reported by Sahu et. al in "GVE-Leiden: Fast Leiden Algorithm for Community
-     * Detection in Shared Memory Setting", the current implementation in NetworKit might create a
-     * small fraction of disconnected communities. Since this violates the guarantees from the
-     * original algorithm, ParallelLeidenView should be used with caution. In addition the
-     * modularity value of the resulting partition / clustering can be lower compared to other
-     * Leiden implementations and even Louvain.
-     *
-     * @param graph A networkit graph
-     * @param iterations Number of Leiden Iterations to be run
-     * @param randomize Randomize node order?
-     * @param gamma Resolution parameter
-     */
-    explicit ParallelLeidenView(const Graph &graph, int iterations = 3, bool randomize = true,
-                                double gamma = 1);
-
-    ~ParallelLeidenView();
-
-    void run() override;
-
-    int VECTOR_OVERSIZE = 10000;
-
-private:
-    struct MoveStats {
-        count moved = 0;
-        count movedToSingleton = 0;
-        count marginalMovesRejected = 0;
-        double gainMarginSum = 0.0;
-        double gainMarginMin = std::numeric_limits<double>::max();
-        double gainMarginMax = std::numeric_limits<double>::lowest();
-    };
-
-    // Template interface to work with both Graph and CoarsenedGraphView
-    template <typename GraphType>
-    void calculateVolumes(const GraphType &graph);
-
-    template <typename GraphType>
-    MoveStats parallelMove(const GraphType &graph);
-
-    template <typename GraphType>
-    Partition parallelRefine(const GraphType &graph);
-
-    inline double modularityDelta(double cutD, double degreeV, double volD) const {
-        return cutD - gamma * degreeV * volD * inverseGraphVolume;
-    };
-
-    inline double modularityThreshold(double cutC, double volC, double degreeV) const {
-        return cutC - gamma * (volC - degreeV) * degreeV * inverseGraphVolume;
-    }
-
-    static inline void lockLowerFirst(index a, index b, std::vector<std::mutex> &locks) {
-        if (a < b) {
-            locks[a].lock();
-            locks[b].lock();
-        } else {
-            locks[b].lock();
-            locks[a].lock();
-        }
-    }
-
-    void flattenPartition();
-
-    double inverseGraphVolume; // 1/vol(V)
-
-    std::vector<double> communityVolumes;
-
-    std::vector<node> composedMapping;
-
-    static constexpr int WORKING_SIZE = 1000;
-
-    double gamma; // Resolution parameter
-
-    bool changed;
-
-    int numberOfIterations;
-
-    Aux::SignalHandler handler;
-
-    bool random;
-
-    // Current coarsened graph view (only keep current, not all historical)
-    std::shared_ptr<CoarsenedGraphView> currentCoarsenedView;
-
-    // Reject moves whose gain margin is too small (numerical-noise churn filter).
-    double moveGainMarginEpsilon = 1e-4;
-
-    // Maximum inner iterations per Leiden iteration.
-    int maxInnerIterations = 20;
-
-    // Optional convergence stop: minimum relative reduction in community count per inner iter.
-    // 0.0 disables this criterion.
-    double minCommunityReduction = 0.0;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_PARALLEL_LEIDEN_VIEW_HPP_

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

@@ -1,30 +0,0 @@
-#ifndef NETWORKIT_COMMUNITY_PARTITION_FRAGMENTATION_HPP_
-#define NETWORKIT_COMMUNITY_PARTITION_FRAGMENTATION_HPP_
-
-#include <networkit/community/LocalPartitionEvaluation.hpp>
-
-namespace NetworKit {
-
-/**
- * This measure evaluates how fragmented a partition is. The fragmentation of a single cluster is
- * defined as one minus the number of nodes in its maximum connected components divided by its total
- * number of nodes. Smaller values thus indicate a smaller fragmentation.
- */
-class PartitionFragmentation final : public LocalPartitionEvaluation {
-public:
-    using LocalPartitionEvaluation::LocalPartitionEvaluation;
-
-    /**
-     * Execute the algorithm. The algorithm is not parallel.
-     */
-    void run() override;
-
-    /**
-     * @return true - smaller values are better than larger values.
-     */
-    bool isSmallBetter() const override { return true; };
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_PARTITION_FRAGMENTATION_HPP_

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

@@ -1,37 +0,0 @@
-#ifndef NETWORKIT_COMMUNITY_PARTITION_HUB_DOMINANCE_HPP_
-#define NETWORKIT_COMMUNITY_PARTITION_HUB_DOMINANCE_HPP_
-
-#include <networkit/community/LocalPartitionEvaluation.hpp>
-
-namespace NetworKit {
-
-/**
- * A quality measure that measures the dominance of hubs in clusters. The hub dominance of a single
- * cluster is defined as the maximum cluster-internal degree of a node in that cluster divided by
- * the maximum cluster-internal degree, i.e. the number of nodes in the cluster minus one. The
- * value for all clusters is defined as the average of all clusters.
- * Strictly speaking this is not a quality measure as this is rather dependent on the type of the
- * considered graph, for more information see
- * Lancichinetti A, Kivel M, Saramki J, Fortunato S (2010)
- * Characterizing the Community Structure of Complex Networks
- * PLoS ONE 5(8): e11976. doi: 10.1371/journal.pone.0011976
- * http://www.plosone.org/article/info%3Adoi%2F10.1371%2Fjournal.pone.0011976
- */
-class PartitionHubDominance final : public LocalPartitionEvaluation {
-public:
-    using LocalPartitionEvaluation::LocalPartitionEvaluation;
-
-    /**
-     * Execute the algorithm. The algorithm is not parallel.
-     */
-    void run() override;
-
-    /**
-     * @return false - small values are not better, large values indicate better cluster cohesion.
-     */
-    bool isSmallBetter() const override { return false; }
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_PARTITION_HUB_DOMINANCE_HPP_