@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,75 @@
+/*
+ * ClusteringGenerator.hpp
+ *
+ *  Created on: 10.12.2012
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_COMMUNITY_CLUSTERING_GENERATOR_HPP_
+#define NETWORKIT_COMMUNITY_CLUSTERING_GENERATOR_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * Provides several methods for generating special clusterings.
+ */
+class ClusteringGenerator final {
+
+public:
+    /**
+     * Make a singleton clustering of Graph @a G, i.e. a clustering in which every node
+     * belongs to its own cluster.
+     *
+     * @param G The graph.
+     * @return A Partition in which every node belongs to its own cluster.
+     */
+    Partition makeSingletonClustering(const Graph &G);
+
+    /**
+     * Make a 1-clustering of Graph @a G, i.e. a clustering in which all nodes belong to the same
+     * cluster.
+     *
+     * @param G The graph.
+     * @return A Partition in which all nodes belong to the same cluster.
+     */
+    Partition makeOneClustering(const Graph &G);
+
+    /**
+     * Make a clustering of Graph @a G with @a k clusters to which the nodes are randomly assigned.
+     *
+     * @param G The graph.
+     * @param k The amount of clusters.
+     * @return A Partition with @a k clusters and each node randomly assigned to one of them.
+     */
+    Partition makeRandomClustering(const Graph &G, count k);
+
+    /**
+     * Make a clustering of Graph @a G with @a k clusters. The first n/k nodes are assigned to the
+     * first cluster, the next n/k nodes to the second cluster and so on.
+     *
+     * @param G The graph.
+     * @param k The amount of clusters.
+     * @return A Partition with @a k clusters and each node assigned like described above.
+     */
+    Partition makeContinuousBalancedClustering(const Graph &G, count k);
+
+    /**
+     * Make a clustering of a Graph @a G with @a k clusters. Each node u is assigned to cluster u %
+     * k. When the number of nodes n is quadratic and k is the square root of n, this clustering is
+     * complementary to the continuous balanced clustering in the sense that no pair of nodes that
+     * is in the same cluster in one of the clusterings is in the same cluster in the other
+     * clustering.
+     *
+     * @param G The graph.
+     * @param k The amount of clusters.
+     * @return A Partition with @a k clusters and each node assigned as described above.
+     */
+    Partition makeNoncontinuousBalancedClustering(const Graph &G, count k);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_CLUSTERING_GENERATOR_HPP_

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

@@ -0,0 +1,58 @@
+/*
+ * CommunityDetectionAlgorithm.hpp
+ *
+ *  Created on: 30.10.2012
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_COMMUNITY_COMMUNITY_DETECTION_ALGORITHM_HPP_
+#define NETWORKIT_COMMUNITY_COMMUNITY_DETECTION_ALGORITHM_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * Abstract base class for community detection/graph clustering algorithms.
+ */
+class CommunityDetectionAlgorithm : public Algorithm {
+public:
+    /**
+     * A community detection algorithm operates on a graph, so the constructor expects a graph.
+     *
+     * @param[in] G input graph
+     */
+    CommunityDetectionAlgorithm(const Graph &G);
+
+    /**
+     * A community detection algorithm operates on a graph, so the constructor expects a graph.
+     *
+     * @param[in] G input graph
+     * @param[in] baseClustering optional; the algorithm will start from the given clustering.
+     */
+    CommunityDetectionAlgorithm(const Graph &G, Partition baseClustering);
+
+    /** Default destructor */
+    ~CommunityDetectionAlgorithm() override = default;
+
+    /**
+     * Apply algorithm to graph
+     */
+    void run() override = 0;
+
+    /**
+     * Returns the result of the run method or throws an error, if the algorithm hasn't run yet.
+     * @return partition of the node set
+     */
+    virtual const Partition &getPartition() const;
+
+protected:
+    const Graph *G;
+    Partition result;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_COMMUNITY_DETECTION_ALGORITHM_HPP_

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

@@ -0,0 +1,32 @@
+/*
+ * Conductance.hpp
+ *
+ *  Created on: 26.02.2014
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_COMMUNITY_CONDUCTANCE_HPP_
+#define NETWORKIT_COMMUNITY_CONDUCTANCE_HPP_
+
+#include <networkit/auxiliary/NumericTools.hpp>
+#include <networkit/community/EdgeCut.hpp>
+#include <networkit/community/QualityMeasure.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * Compute conductance of a 2-partition, i.e. cut size over volume of smaller set (smaller in
+ * terms of volume).
+ */
+class Conductance final : public QualityMeasure {
+public:
+    /**
+     * @return Conductance of 2-partition @a zeta in graph @a G.
+     * Requires cluster IDs to be either 0 or 1.
+     */
+    double getQuality(const Partition &zeta, const Graph &G) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_CONDUCTANCE_HPP_

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

@@ -0,0 +1,53 @@
+#ifndef NETWORKIT_COMMUNITY_COVER_F1_SIMILARITY_HPP_
+#define NETWORKIT_COMMUNITY_COVER_F1_SIMILARITY_HPP_
+
+#include <networkit/community/LocalCoverEvaluation.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * Compare a given cover to a reference cover using the F1 measure.
+ * This is a typical similarity measure used to compare the found
+ * overlapping community structure to a ground truth community
+ * structure. Each cluster is compared to the best-matching reference
+ * cluster (in terms of highest F1 score). A value of 1 indicates
+ * perfect agreement while a while of 0 indicates complete
+ * disagreement. An example where this measure is used is the
+ * following paper:
+ *
+ * Alessandro Epasto, Silvio Lattanzi, and Renato Paes
+ * Leme. 2017. Ego-Splitting Framework: from Non-Overlapping to
+ * Overlapping Clusters. In Proceedings of the 23rd ACM SIGKDD
+ * International Conference on Knowledge Discovery and Data Mining
+ * (KDD '17). ACM, New York, NY, USA, 145-154. DOI:
+ * https://doi.org/10.1145/3097983.3098054
+ */
+class CoverF1Similarity final : public LocalCoverEvaluation {
+public:
+    /**
+     * Initialize the cover F1 similarity.
+     *
+     * @param G The graph on which the evaluation is performed.
+     * @param C The cover that shall be evaluated.
+     * @param reference The reference cover to which @a C shall be compared.
+     */
+    CoverF1Similarity(const Graph &G, const Cover &C, const Cover &reference);
+
+    /**
+     * Execute the algorithm. The algorithm is not parallel.
+     */
+    void run() override;
+
+    /**
+     * @return false - smaller is not better, larger values indicate better matching clusters.
+     */
+    bool isSmallBetter() const override { return false; }
+
+private:
+    const Cover *reference;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_COVER_F1_SIMILARITY_HPP_

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

@@ -0,0 +1,38 @@
+#ifndef NETWORKIT_COMMUNITY_COVER_HUB_DOMINANCE_HPP_
+#define NETWORKIT_COMMUNITY_COVER_HUB_DOMINANCE_HPP_
+
+#include <networkit/community/LocalCoverEvaluation.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.
+ * This implementation is a natural generalization of this measure for covers.
+ * 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 CoverHubDominance final : public LocalCoverEvaluation {
+public:
+    using LocalCoverEvaluation::LocalCoverEvaluation;
+
+    /**
+     * Execute the algorithm. The algorithm is not parallel.
+     */
+    void run() override;
+
+    /**
+     * @return false - smaller is not better, larger values indicate better cluster cohesion.
+     */
+    bool isSmallBetter() const override { return false; }
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_COVER_HUB_DOMINANCE_HPP_

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

@@ -0,0 +1,25 @@
+/*
+ * Coverage.hpp
+ *
+ *  Created on: 02.02.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_COMMUNITY_COVERAGE_HPP_
+#define NETWORKIT_COMMUNITY_COVERAGE_HPP_
+
+#include <networkit/community/QualityMeasure.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * Coverage is the fraction of intra-cluster edges.
+ */
+class Coverage final : public QualityMeasure {
+public:
+    double getQuality(const Partition &zeta, const Graph &G) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_COVERAGE_HPP_

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

@@ -0,0 +1,62 @@
+#ifndef NETWORKIT_COMMUNITY_CUT_CLUSTERING_HPP_
+#define NETWORKIT_COMMUNITY_CUT_CLUSTERING_HPP_
+
+#include <networkit/community/CommunityDetectionAlgorithm.hpp>
+
+namespace NetworKit {
+
+/**
+ * Cut clustering algorithm as defined in
+ * Flake, Gary William; Tarjan, Robert E.; Tsioutsiouliklis, Kostas. Graph Clustering and Minimum
+ * Cut Trees. Internet Mathematics 1 (2003), no. 4, 385--408.
+ */
+class CutClustering final : public CommunityDetectionAlgorithm {
+public:
+    /**
+     * Initialize cut clustering algorithm with parameter alpha.
+     *
+     * A value of 0 gives a clustering with one cluster with all nodes,
+     * A value that equals to the largest edge weight gives singleton clusters.
+     *
+     * @param alpha The parameter for the cut clustering
+     */
+    CutClustering(const Graph &G, edgeweight alpha);
+
+    /**
+     * Apply algorithm to graph
+     *
+     * Warning: due to numerical errors the resulting clusters might not be correct.
+     * This implementation uses the Edmonds-Karp algorithm for the cut calculation.
+     */
+    void run() override;
+
+    /**
+     * Get the complete hierarchy with all possible parameter values.
+     *
+     * Each reported parameter value is the lower bound for the range in which the corresponding
+     * clustering is calculated by the cut clustering algorithm.
+     *
+     * Warning: all reported parameter values are slightly too high in order to avoid wrong
+     * clusterings because of numerical inaccuracies. Furthermore the completeness of the hierarchy
+     * cannot be guaranteed because of these inaccuracies. This implementation hasn't been optimized
+     * for performance.
+     *
+     * @param G The Graph instance for which the hierarchy shall be calculated
+     *
+     * @return The hierarchy as map
+     */
+    static std::map<edgeweight, Partition> getClusterHierarchy(const Graph &G);
+
+private:
+    /**
+     * Helper function for the recursive clustering hierarchy calculation.
+     */
+    static void clusterHierarchyRecursion(const Graph &G, edgeweight lower, Partition lowerClusters,
+                                          edgeweight upper, Partition upperClusters,
+                                          std::map<edgeweight, Partition> &result);
+    edgeweight alpha;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_CUT_CLUSTERING_HPP_

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

@@ -0,0 +1,31 @@
+/*
+ * DissimilarityMeasure.hpp
+ *
+ *  Created on: 19.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_COMMUNITY_DISSIMILARITY_MEASURE_HPP_
+#define NETWORKIT_COMMUNITY_DISSIMILARITY_MEASURE_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Cover.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * Base class for all clustering dissimilarity measures.
+ */
+class DissimilarityMeasure {
+
+public:
+    virtual double getDissimilarity(const Graph &G, const Partition &first,
+                                    const Partition &second) = 0;
+
+    virtual double getDissimilarity(const Graph &G, const Cover &first, const Cover &second);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_DISSIMILARITY_MEASURE_HPP_

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

@@ -0,0 +1,44 @@
+/*
+ * DynamicNMIDistance.hpp
+ *
+ *  Created on: Jun 26, 2013
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_COMMUNITY_DYNAMIC_NMI_DISTANCE_HPP_
+#define NETWORKIT_COMMUNITY_DYNAMIC_NMI_DISTANCE_HPP_
+
+#include <networkit/community/DissimilarityMeasure.hpp>
+#include <networkit/community/NMIDistance.hpp>
+
+namespace NetworKit {
+
+using Matrix = std::vector<std::vector<count>>;
+
+/**
+ * @ingroup community
+ */
+class DynamicNMIDistance final : public DissimilarityMeasure {
+public:
+    /**
+     * Computes NMI between two clusterings that belong to two different graphs.
+     * @a newGraph has evolved from oldGraph, which is only given implicitly via
+     * @a oldClustering. NMI is only applied to nodes that belong to the intersection
+     * of oldGraph and @a newGraph. Nodes of oldGraph not existing in @newGraph are
+     * marked by the entry none in @a newClustering.
+     */
+    double getDissimilarity(const Graph &newGraph, const Partition &oldClustering,
+                            const Partition &newClustering) override;
+
+    void combineValues(double H_sum, double MI, double &NMI, double &NMID) const;
+    void sanityCheck(double &NMI, double &NMID) const;
+
+    double entropy(const Partition &clustering, count n, std::vector<double> probs);
+
+    bool isInBoth(node u, const Partition &oldClustering, const Partition &newClustering);
+
+    Matrix confusionMatrix(const Graph &G, const Partition &zeta, const Partition &eta);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_DYNAMIC_NMI_DISTANCE_HPP_

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

@@ -0,0 +1,24 @@
+/*
+ * EdgeCut.hpp
+ *
+ *  Created on: Jun 20, 2013
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_COMMUNITY_EDGE_CUT_HPP_
+#define NETWORKIT_COMMUNITY_EDGE_CUT_HPP_
+
+#include <networkit/community/QualityMeasure.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ */
+class EdgeCut final : public QualityMeasure {
+public:
+    double getQuality(const Partition &zeta, const Graph &G) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_EDGE_CUT_HPP_

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

@@ -0,0 +1,103 @@
+/*
+ * GraphClusteringTools.hpp
+ */
+
+#ifndef NETWORKIT_COMMUNITY_GRAPH_CLUSTERING_TOOLS_HPP_
+#define NETWORKIT_COMMUNITY_GRAPH_CLUSTERING_TOOLS_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ */
+namespace GraphClusteringTools {
+
+/**
+ * Get the imbalance of clusters in the given partition.
+ *
+ * @param zeta Input partition
+ * @return total imbalance between clusters
+ */
+float getImbalance(const Partition &zeta);
+
+/**
+ * Get the imbalance of clusters in the given partition compared to a given graph.
+ *
+ * @param zeta Input partition
+ * @param graph Input graph
+ * @return total imbalance between clusters
+ */
+float getImbalance(const Partition &zeta, const Graph &graph);
+
+/**
+ * Get the communication graph for a given graph and its partition.
+ * A communication graph consists of a number of nodes, which equal
+ * the number of clusters in the partition. The edges between nodes
+ * in the communication graph account for the total edge weight for all
+ * edges between two clusters. For unweighted graphs, the edge weight in
+ * the communication graph is equal to the number of edges between two
+ * clusters.
+ *
+ * @param graph The input graph
+ * @param zeta Partition, which contains information about clusters in the graph
+ * @return communication graph
+ */
+GraphW communicationGraph(const Graph &graph, Partition &zeta);
+
+/**
+ * Get weightedDegree of node u for a cluster (represented by a partition) of index cid.
+ *
+ * @param graph The input graph
+ * @param zeta Partition, which contains information about clusters in the graph
+ * @param u node
+ * @param cid index of cluster
+ * @return weighted degree of node u for cluster index cid
+ */
+edgeweight weightedDegreeWithCluster(const Graph &graph, const Partition &zeta, node u, index cid);
+
+/**
+ * Check whether a partition is a proper clustering for a given graph
+ *
+ * @param graph The input graph
+ * @param zeta Partition, which contains information about clusters in the graph
+ * @return True if the partition is a proper clustering, False if not
+ */
+bool isProperClustering(const Graph &G, const Partition &zeta);
+
+/**
+ * Check whether a partition is a proper singleton clustering for a given graph
+ *
+ * @param graph The input graph
+ * @param zeta Partition, which contains information about clusters in the graph
+ * @return True if the partition is a proper singleton clustering, False if not
+ */
+bool isSingletonClustering(const Graph &G, const Partition &zeta);
+
+/**
+ * Check whether a partition is a proper one clustering for a given graph
+ *
+ * @param graph The input graph
+ * @param zeta Partition, which contains information about clusters in the graph
+ * @return True if the partition is a proper one clustering, False if not
+ */
+bool isOneClustering(const Graph &G, const Partition &zeta);
+
+/**
+ * Check whether two paritions are equal for a given graph
+ *
+ * @param graph The input graph
+ * @param zeta Partition, which contains information about clusters in the graph
+ * @param eta Partition, which contains information about clusters in the graph
+ * @return True if both partitions are the same, False if not
+ */
+bool equalClusterings(const Partition &zeta, const Partition &eta, Graph &G);
+
+} // namespace GraphClusteringTools
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_GRAPH_CLUSTERING_TOOLS_HPP_

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

@@ -0,0 +1,28 @@
+/*
+ * GraphStructuralRandMeasure.hpp
+ *
+ *  Created on: 16.04.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_COMMUNITY_GRAPH_STRUCTURAL_RAND_MEASURE_HPP_
+#define NETWORKIT_COMMUNITY_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.
+ */
+class GraphStructuralRandMeasure final : public DissimilarityMeasure {
+
+public:
+    double getDissimilarity(const Graph &G, const Partition &first,
+                            const Partition &second) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_GRAPH_STRUCTURAL_RAND_MEASURE_HPP_

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

@@ -0,0 +1,46 @@
+#ifndef NETWORKIT_COMMUNITY_HUB_DOMINANCE_HPP_
+#define NETWORKIT_COMMUNITY_HUB_DOMINANCE_HPP_
+
+#include <networkit/community/QualityMeasure.hpp>
+#include <networkit/structures/Cover.hpp>
+#include <networkit/structures/Partition.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 HubDominance final : public QualityMeasure {
+public:
+    /**
+     * Calculates the dominance of hubs in the given Partition @a zeta of the given
+     * Graph @a G.
+     *
+     * @param zeta The partition for which the hub dominance shall be calculated
+     * @param G The graph that is partitioned in @a zeta
+     * @return The average hub dominance of @a zeta
+     */
+    double getQuality(const Partition &zeta, const Graph &G) override;
+    /**
+     * Calculates the dominance of hubs in the given Cover @a zeta of the given
+     * Graph @a G.
+     *
+     * @param zeta The cover for which the hub dominance shall be calculated
+     * @param G The graph that is partitioned in @a zeta
+     * @return The average hub dominance of @a zeta
+     */
+    double getQuality(const Cover &zeta, const Graph &G);
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_HUB_DOMINANCE_HPP_

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

@@ -0,0 +1,44 @@
+#ifndef NETWORKIT_COMMUNITY_INTRAPARTITION_DENSITY_HPP_
+#define NETWORKIT_COMMUNITY_INTRAPARTITION_DENSITY_HPP_
+
+#include <networkit/community/LocalPartitionEvaluation.hpp>
+
+namespace NetworKit {
+
+/**
+ * The intra-cluster density of a partition is defined as the number of existing edges divided by
+ * the number of possible edges. The global value is the sum of all existing intra-cluster edges
+ * divided by the sum of all possible intra-cluster edges.
+ */
+class IntrapartitionDensity final : public LocalPartitionEvaluation {
+public:
+    using LocalPartitionEvaluation::LocalPartitionEvaluation;
+
+    /**
+     * Execute the algorithm. The algorithm is not parallel.
+     */
+    void run() override;
+
+    /**
+     * Get the global intra-cluster density.
+     *
+     * @return The global intra-cluster density.
+     */
+    double getGlobal() const {
+        assureFinished();
+        return globalValue;
+    };
+
+    /**
+     * This value should be high in a good clustering.
+     * @return false - high values are better than small values.
+     */
+    bool isSmallBetter() const override { return false; }
+
+private:
+    double globalValue;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_INTRAPARTITION_DENSITY_HPP_