@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,40 @@
+#ifndef NETWORKIT_COMMUNITY_ISOLATED_INTERPARTITION_CONDUCTANCE_HPP_
+#define NETWORKIT_COMMUNITY_ISOLATED_INTERPARTITION_CONDUCTANCE_HPP_
+
+#include <networkit/community/LocalPartitionEvaluation.hpp>
+
+namespace NetworKit {
+
+/**
+ * Isolated inter-partition conductance is a measure for how well a partition
+ * (communtiy/cluster) is separated from the rest of the graph.
+ *
+ * The conductance of a partition is defined as the weight of the cut divided
+ * by the volume (the sum of the degrees) of the nodes in the partition or the
+ * nodes in the rest of the graph, whatever is smaller. Small values thus indicate
+ * that the cut is small compared to the volume of the smaller of the separated
+ * parts. For the whole partitions usually the maximum or the unweighted average
+ * is used.
+ *
+ * See also Experiments on Density-Constrained Graph Clustering,
+ * Robert Gorke, Andrea Kappes and  Dorothea Wagner, JEA 2015:
+ * http://dx.doi.org/10.1145/2638551
+ */
+class IsolatedInterpartitionConductance 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_ISOLATED_INTERPARTITION_CONDUCTANCE_HPP_

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

@@ -0,0 +1,40 @@
+#ifndef NETWORKIT_COMMUNITY_ISOLATED_INTERPARTITION_EXPANSION_HPP_
+#define NETWORKIT_COMMUNITY_ISOLATED_INTERPARTITION_EXPANSION_HPP_
+
+#include <networkit/community/LocalPartitionEvaluation.hpp>
+
+namespace NetworKit {
+
+/**
+ * Isolated inter-partition expansion is a measure for how well a partition
+ * (communtiy/cluster) is separated from the rest of the graph.
+ *
+ * The expansion of a partition is defined as the weight of the cut divided
+ * by number of nodes in the partition or in the rest of the graph, whatever
+ * is smaller. Small values thus indicate that the cut is small compared to
+ * the size of the smaller of the separated parts. For the whole partitions
+ * usually the maximum or the unweighted average is used. Note that expansion
+ * values can be larger than 1.
+ *
+ * See also Experiments on Density-Constrained Graph Clustering,
+ * Robert Grke, Andrea Kappes and Dorothea Wagner, JEA 2015:
+ * http://dx.doi.org/10.1145/2638551
+ */
+class IsolatedInterpartitionExpansion 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_ISOLATED_INTERPARTITION_EXPANSION_HPP_

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

@@ -0,0 +1,25 @@
+/*
+ * JaccardMeasure.hpp
+ *
+ *  Created on: 19.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_COMMUNITY_JACCARD_MEASURE_HPP_
+#define NETWORKIT_COMMUNITY_JACCARD_MEASURE_HPP_
+
+#include <networkit/community/DissimilarityMeasure.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ */
+class JaccardMeasure final : public DissimilarityMeasure {
+
+public:
+    double getDissimilarity(const Graph &G, const Partition &zeta, const Partition &eta) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_JACCARD_MEASURE_HPP_

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

@@ -0,0 +1,49 @@
+/*
+ * LFM.hpp
+ *
+ *  Created on 10.12.2020
+ *      Author: John Gelhausen
+ */
+
+#ifndef NETWORKIT_COMMUNITY_LFM_HPP_
+#define NETWORKIT_COMMUNITY_LFM_HPP_
+
+#include <networkit/community/OverlappingCommunityDetectionAlgorithm.hpp>
+#include <networkit/scd/SelectiveCommunityDetector.hpp>
+
+namespace NetworKit {
+/**
+ * @ingroup community
+ * This is the local community expansion algorithm as introduced in:
+ *
+ * Lancichinetti, A., Fortunato, S., & Kertész, J. (2009).
+ * Detecting the overlapping and hierarchical community structure in complex networks.
+ * New Journal of Physics, 11(3), 033015.
+ * https://doi.org/10.1088/1367-2630/11/3/033015
+ *
+ * The LFM algorithm detects overlapping communities by repeatedly
+ * executing a given SelectiveCommunityDetector algorithm
+ * for different random seed nodes which have not yet been assigned to any community.
+ * While this implementation allows the use of any local community detection algorithm, the behavior
+ * of the original algorithm can be achieved using the LFMLocal local community detection algorithm.
+ */
+class LFM final : public OverlappingCommunityDetectionAlgorithm {
+public:
+    /**
+     * @param G Input graph
+     * @param scd The algorithm that is used to expand the random seed nodes to communities
+     *
+     */
+    LFM(const Graph &G, SelectiveCommunityDetector &scd);
+
+    /**
+     * Detect communities
+     */
+    void run() override;
+
+protected:
+    SelectiveCommunityDetector *scd;
+};
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_COMMUNITY_LFM_HPP_

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

@@ -0,0 +1,48 @@
+/*
+ * LPDegreeOrdered.hpp
+ *
+ *  Created on: 24.09.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_COMMUNITY_LP_DEGREE_ORDERED_HPP_
+#define NETWORKIT_COMMUNITY_LP_DEGREE_ORDERED_HPP_
+
+#include <networkit/community/CommunityDetectionAlgorithm.hpp>
+
+namespace NetworKit {
+
+using label = index; // a label is the same as a cluster id
+
+/**
+ * @ingroup community
+ * Label propagation-based community detection algorithm which
+ * processes nodes in increasing order of node degree.
+ */
+class LPDegreeOrdered final : public CommunityDetectionAlgorithm {
+private:
+    count nIterations = 0; //!< number of iterations in last run
+
+public:
+    /**
+     * Constructor to the degree ordered label propagation community detection algorithm.
+     *
+     * @param[in] G input graph
+     */
+    LPDegreeOrdered(const Graph &G);
+
+    /**
+     * Detect communities.
+     */
+    void run() override;
+
+    /**
+     * Get number of iterations in last run.
+     *
+     * @return Number of iterations.
+     */
+    count numberOfIterations();
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_LP_DEGREE_ORDERED_HPP_

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

@@ -0,0 +1,100 @@
+#ifndef NETWORKIT_COMMUNITY_LOCAL_COMMUNITY_EVALUATION_HPP_
+#define NETWORKIT_COMMUNITY_LOCAL_COMMUNITY_EVALUATION_HPP_
+
+#include <vector>
+
+#include <networkit/Globals.hpp>
+#include <networkit/base/Algorithm.hpp>
+
+namespace NetworKit {
+
+/**
+ * Virtual base class of all evaluation methods for a single clustering which is based on the
+ * evaluation of single clusters. This is the base class both for Partitions as well as for Covers.
+ */
+class LocalCommunityEvaluation : public Algorithm {
+public:
+    /**
+     * Default destructor for the virtual base class
+     */
+    ~LocalCommunityEvaluation() override = default;
+
+    /**
+     * Get the average value weighted by cluster size.
+     *
+     * @return The weighted average value.
+     */
+    double getWeightedAverage() const {
+        assureFinished();
+        return weightedAverage;
+    };
+
+    /**
+     * Get the (unweighted) average value of all clusters.
+     *
+     * @return The unweighted average value.
+     */
+    double getUnweightedAverage() const {
+        assureFinished();
+        return unweightedAverage;
+    };
+
+    /**
+     * Get the maximum value of all clusters.
+     *
+     * @return The maximum value.
+     */
+    double getMaximumValue() const {
+        assureFinished();
+        return maximumValue;
+    };
+
+    /**
+     * Get the minimum value of all clusters.
+     *
+     * @return The minimum value.
+     */
+    double getMinimumValue() const {
+        assureFinished();
+        return minimumValue;
+    };
+
+    /**
+     * Get the value of the specified cluster.
+     *
+     * @param i The cluster to get the value for.
+     * @return The value of cluster @a i.
+     */
+    double getValue(index i) const {
+        assureFinished();
+        return values[i];
+    };
+
+    /**
+     * Get the values of all clusters.
+     *
+     * @return The values of all clusters.
+     */
+    std::vector<double> getValues() const {
+        assureFinished();
+        return values;
+    };
+
+    /**
+     * If small values are better (otherwise large values are better).
+     *
+     * @return If small values are better.
+     */
+    virtual bool isSmallBetter() const = 0;
+
+protected:
+    double weightedAverage;
+    double unweightedAverage;
+    double maximumValue;
+    double minimumValue;
+    std::vector<double> values;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_LOCAL_COMMUNITY_EVALUATION_HPP_

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

@@ -0,0 +1,31 @@
+#ifndef NETWORKIT_COMMUNITY_LOCAL_COVER_EVALUATION_HPP_
+#define NETWORKIT_COMMUNITY_LOCAL_COVER_EVALUATION_HPP_
+
+#include <networkit/community/LocalCommunityEvaluation.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Cover.hpp>
+
+namespace NetworKit {
+
+/**
+ * Virtual base class of all evaluation methods for a single Cover which is based on the evaluation
+ * of single clusters. This is the base class for Covers.
+ */
+class LocalCoverEvaluation : public LocalCommunityEvaluation {
+public:
+    /**
+     * Initialize the cover evaluation method.
+     *
+     * @param G The graph on which the evaluation shall be performed
+     * @param C The cover that shall be evaluated.
+     */
+    LocalCoverEvaluation(const Graph &G, const Cover &C);
+
+protected:
+    const Graph *G;
+    const Cover *C;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_LOCAL_COVER_EVALUATION_HPP_

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

@@ -0,0 +1,31 @@
+#ifndef NETWORKIT_COMMUNITY_LOCAL_PARTITION_EVALUATION_HPP_
+#define NETWORKIT_COMMUNITY_LOCAL_PARTITION_EVALUATION_HPP_
+
+#include <networkit/community/LocalCommunityEvaluation.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * Virtual base class of all evaluation methods for a single Partition which is based on the
+ * evaluation of single clusters. This is the base class for Partitions.
+ */
+class LocalPartitionEvaluation : public LocalCommunityEvaluation {
+public:
+    /**
+     * Initialize the partition evaluation method.
+     *
+     * @param G The graph on which the evaluation shall be performed
+     * @param P The partition that shall be evaluated.
+     */
+    LocalPartitionEvaluation(const Graph &G, const Partition &P);
+
+protected:
+    const Graph *G;
+    const Partition *P;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_LOCAL_PARTITION_EVALUATION_HPP_

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

@@ -0,0 +1,135 @@
+/*
+ * LouvainMapEquation.hpp
+ *
+ * Created on: 2019-01-28
+ * Author: Armin Wiebigke
+ *         Michael Hamann
+ *         Lars Gottesbüren
+ */
+
+#ifndef NETWORKIT_COMMUNITY_LOUVAIN_MAP_EQUATION_HPP_
+#define NETWORKIT_COMMUNITY_LOUVAIN_MAP_EQUATION_HPP_
+
+#include <networkit/auxiliary/SparseVector.hpp>
+#include <networkit/auxiliary/SpinLock.hpp>
+#include <networkit/community/CommunityDetectionAlgorithm.hpp>
+
+namespace NetworKit {
+
+class LouvainMapEquation : public CommunityDetectionAlgorithm {
+public:
+    enum class ParallelizationType : uint8_t {
+        NONE,
+        RELAX_MAP,
+        SYNCHRONOUS,
+        None = NONE, // this + following added for backwards compatibility
+        RelaxMap = RELAX_MAP,
+        Synchronous = SYNCHRONOUS
+    };
+
+public:
+    /**
+     * @param[in] G input graph
+     * @param[in] hierarchical use recursive coarsening
+     * @param[in] maxIterations maximum number of iterations for move phase
+     * @param[in] parallelization strategy (default synchronous):
+     *            none
+     *            relaxmap    -> one lock per community to update cuts
+     *            synchronous -> work on stale cuts and volumes, update in second step
+     *
+     */
+    explicit LouvainMapEquation(const Graph &graph, bool hierarchical = false,
+                                count maxIterations = 32,
+                                std::string_view parallelizationStrategy = "relaxmap");
+    /**
+     * @param[in] G input graph
+     * @param[in] hierarchical use recursive coarsening
+     * @param[in] maxIterations maximum number of iterations for move phase
+     * @param[in] parallelization strategy (default synchronous):
+     *            none
+     *            relaxmap    -> one lock per community to update cuts
+     *            synchronous -> work on stale cuts and volumes, update in second step
+     *
+     */
+    explicit LouvainMapEquation(const Graph &graph, bool hierarchical, count maxIterations,
+                                ParallelizationType parallelizationType);
+
+    void run() override;
+
+private:
+    struct Move {
+        node movedNode = none;
+        double volume = 0.0;
+        index originCluster = none, targetCluster = none;
+        double cutUpdateToOriginCluster = 0.0, cutUpdateToTargetCluster = 0.0;
+
+        Move(node n, double vol, index cc, index tc, double cuptoc, double cupttc)
+            : movedNode(n), volume(vol), originCluster(cc), targetCluster(tc),
+              cutUpdateToOriginCluster(cuptoc), cutUpdateToTargetCluster(cupttc) {}
+    };
+
+    static_assert(std::is_trivially_destructible<Move>::value,
+                  "LouvainMapEquation::Move struct is not trivially destructible");
+
+    ParallelizationType parallelizationType;
+    bool parallel;
+
+    bool hierarchical;
+    count maxIterations;
+
+    std::vector<double> clusterCut, clusterVolume;
+    double totalCut, totalVolume;
+
+    // for RelaxMap
+    std::vector<Aux::Spinlock> locks;
+
+    // for SLM
+    Partition nextPartition;
+    std::vector<SparseVector<double>> ets_neighborClusterWeights;
+
+    count localMoving(std::vector<node> &nodes, count iteration);
+
+    count synchronousLocalMoving(std::vector<node> &nodes, count iteration);
+
+    bool tryLocalMove(node u, SparseVector<double> &neighborClusterWeights,
+                      std::vector<Move> &moves, bool synchronous);
+
+    bool performMove(node u, double degree, double loopWeight, node currentCluster,
+                     node targetCluster, double weightToTarget, double weightToCurrent);
+
+    void aggregateAndApplyCutAndVolumeUpdates(std::vector<Move> &moves);
+
+    void calculateInitialClusterCutAndVolume();
+
+    void runHierarchical();
+
+    /**
+     * Calculate the change in the map equation if the node is moved from its current cluster to the
+     * target cluster. To simplify the calculation, we remove terms that are constant for all target
+     * clusters. As a result, "moving" the node to its current cluster gives a value != 0, although
+     * the complete map equation would not change.
+     */
+    double fitnessChange(node, double degree, double loopWeight, node currentCluster,
+                         node targetCluster, double weightToTarget, double weightToCurrent,
+                         double totalCutCurrently);
+
+    count idivCeil(count a, count b) const { return (a + b - 1) / b; }
+
+    std::pair<count, count> chunkBounds(count i, count n, count chunkSize) const {
+        return std::make_pair(i * chunkSize, std::min(n, (i + 1) * chunkSize));
+    }
+
+#ifndef NDEBUG
+    long double sumPLogPwAlpha = 0;
+    long double sumPLogPClusterCut = 0;
+    long double sumPLogPClusterCutPlusVol = 0;
+    double plogpRel(double w);
+    void updatePLogPSums();
+    long double mapEquation();
+    void checkUpdatedCutsAndVolumesAgainstRecomputation();
+#endif // NDEBUG
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_COMMUNITY_LOUVAIN_MAP_EQUATION_HPP_

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

@@ -0,0 +1,54 @@
+/*
+ * Modularity.hpp
+ *
+ *  Created on: 10.12.2012
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_COMMUNITY_MODULARITY_HPP_
+#define NETWORKIT_COMMUNITY_MODULARITY_HPP_
+
+#include <networkit/community/QualityMeasure.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * Modularity is a quality index for community detection. It assigns a quality value in [-0.5, 1.0]
+ * to a partition of a graph which is higher for more modular networks and partitions which better
+ * capture the modular structure.
+ *
+ * Modularity is defined as:
+ *
+ * $$mod(\\zeta) := \\frac{\\sum_{C \\in \\zeta} \\sum_{ e \\in E(C) } \\omega(e)}{\\sum_{e \\in E}
+ * \\omega(e)}
+ * \\frac{ \\sum_{C \\in \\zeta}( \\sum_{v \\in C} \\omega(v) )^2 }{4( \\sum_{e \\in E} \\omega(e)
+ * )^2 }$$
+ */
+class Modularity final : public QualityMeasure {
+
+private:
+    double gTotalEdgeWeight;
+
+public:
+    /** Default constructor */
+    Modularity();
+
+    /**
+     * Returns the Modularity of the given clustering with respect to the graph @a G.
+     *
+     * @param zeta The clustering.
+     * @param G The graph.
+     * @return The modularity.
+     */
+    double getQuality(const Partition &zeta, const Graph &G) override;
+
+    /**
+     * @param totalEdgeWeight Sum of all edge weights in @a G. If specified, it does not
+     *        have to be computed.
+     */
+    void setTotalEdgeWeight(double totalEdgeWeight);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_MODULARITY_HPP_

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

@@ -0,0 +1,28 @@
+/*
+ * NMIDistance.hpp
+ *
+ *  Created on: 30.04.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_COMMUNITY_NMI_DISTANCE_HPP_
+#define NETWORKIT_COMMUNITY_NMI_DISTANCE_HPP_
+
+#include <networkit/community/DissimilarityMeasure.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * NMIDistance quantifies the dissimilarity between two clusterings using
+ * Normalized Mutual Information.
+ *
+ */
+class NMIDistance final : public DissimilarityMeasure {
+
+public:
+    double getDissimilarity(const Graph &G, const Partition &zeta, const Partition &eta) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_NMI_DISTANCE_HPP_

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

@@ -0,0 +1,27 @@
+/*
+ * NodeStructuralRandMeasure.hpp
+ *
+ *  Created on: 19.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_COMMUNITY_NODE_STRUCTURAL_RAND_MEASURE_HPP_
+#define NETWORKIT_COMMUNITY_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 all pairs of nodes.
+ */
+class NodeStructuralRandMeasure final : public DissimilarityMeasure {
+
+public:
+    double getDissimilarity(const Graph &G, const Partition &zeta, const Partition &eta) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_NODE_STRUCTURAL_RAND_MEASURE_HPP_

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

@@ -0,0 +1,51 @@
+/*
+ * OverlappingCommunityDetectionAlgorithm.hpp
+ *
+ *  Created on: 14.12.2020
+ *      Author: John Gelhausen
+ */
+
+#ifndef NETWORKIT_COMMUNITY_OVERLAPPING_COMMUNITY_DETECTION_ALGORITHM_HPP_
+#define NETWORKIT_COMMUNITY_OVERLAPPING_COMMUNITY_DETECTION_ALGORITHM_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Cover.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup community
+ * Abstract base class for overlapping community detection/graph clustering algorithms.
+ */
+class OverlappingCommunityDetectionAlgorithm : public Algorithm {
+public:
+    /**
+     * An overlapping community detection algorithm operates on a graph, so the constructor expects
+     * a graph.
+     *
+     * @param[in] G input graph
+     */
+    OverlappingCommunityDetectionAlgorithm(const Graph &G);
+
+    /** Default destructor */
+    ~OverlappingCommunityDetectionAlgorithm() 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 cover of the node set
+     */
+    const Cover &getCover() const;
+
+protected:
+    const Graph *G;
+    Cover result;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_COMMUNITY_OVERLAPPING_COMMUNITY_DETECTION_ALGORITHM_HPP_