@ladybugmem/icebug 0.1.0

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

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

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

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

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

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

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

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

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