@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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