@ladybugmem/icebug 0.1.0 → 0.1.1

package/vendor/include/networkit/scd/GCE.hpp

@@ -1,42 +0,0 @@
-/* GCE.hpp
- *
- * Created on: 06.05.2013
- * Author: cls
- */
-
-#ifndef NETWORKIT_SCD_GCE_HPP_
-#define NETWORKIT_SCD_GCE_HPP_
-
-#include <unordered_set>
-
-#include <networkit/auxiliary/SetIntersector.hpp>
-#include <networkit/scd/SelectiveCommunityDetector.hpp>
-
-namespace NetworKit {
-
-/**
- * The Greedy Community Expansion algorithm.
- *
- * Greedily adds nodes from the shell to improve community quality.
- */
-class GCE : public SelectiveCommunityDetector {
-
-public:
-    GCE(const Graph &g, std::string objective);
-
-    /**
-     * @param[in]  seeds  seed nodes
-     *
-     * @param[out]        community as a set of nodes
-     */
-    std::set<node> expandOneCommunity(const std::set<node> &seeds) override;
-
-    // inherit method from parent class.
-    using SelectiveCommunityDetector::expandOneCommunity;
-
-private:
-    std::string objective; // name of objective function
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_SCD_GCE_HPP_

package/vendor/include/networkit/scd/LFMLocal.hpp

@@ -1,54 +0,0 @@
-#ifndef NETWORKIT_SCD_LFM_LOCAL_HPP_
-#define NETWORKIT_SCD_LFM_LOCAL_HPP_
-
-#include <networkit/scd/SelectiveCommunityDetector.hpp>
-
-namespace NetworKit {
-
-/**
- * Local version of the LFM algorithm
- *
- * This is the local community expansion 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
- *
- * Their algorithm detects overlapping communities by repeatedly
- * executing this algorithm for a random seed node that has not yet
- * been assigned to any community.
- *
- * The algorithm has a resolution parameter alpha. A natural choice
- * for alpha is 1, the paper states that values below 0.5 usually
- * give a community containing the whole graph while values larger
- * than 2 recover the smallest communities.
- */
-class LFMLocal : public SelectiveCommunityDetector {
-
-public:
-    /**
-     * Construct the LFMLocal algorithm.
-     *
-     * @param G The graph to find a community on.
-     * @param alpha The resolution parameter.
-     */
-    LFMLocal(const Graph &g, double alpha = 1.0);
-
-    using SelectiveCommunityDetector::expandOneCommunity;
-
-    /**
-     * Expand a set of nodes into a single community.
-     *
-     * @param s The set of seed nodes.
-     * @return The found community.
-     */
-    std::set<node> expandOneCommunity(const std::set<node> &s) override;
-
-protected:
-    const double alpha;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_SCD_LFM_LOCAL_HPP_

package/vendor/include/networkit/scd/LocalT.hpp

@@ -1,40 +0,0 @@
-#ifndef NETWORKIT_SCD_LOCAL_T_HPP_
-#define NETWORKIT_SCD_LOCAL_T_HPP_
-
-#include <networkit/scd/SelectiveCommunityDetector.hpp>
-
-namespace NetworKit {
-
-/**
- * The local community expansion algorithm optimizing the T measure.
- *
- * This implements the algorithm published in:
- *
- * Fagnan, J., Zaiane, O., & Barbosa, D. (2014).
- * Using triads to identify local community structure in social networks.
- * In 2014 IEEE/ACM International Conference on Advances in Social Networks Analysis and Mining
- * (ASONAM) (pp. 108–112). https://doi.org/10.1109/ASONAM.2014.6921568
- */
-class LocalT : public SelectiveCommunityDetector {
-public:
-    /**
-     * Constructs the Local T algorithm.
-     *
-     * @param[in] G The graph to detect communities on
-     */
-    LocalT(const Graph &g);
-
-    /**
-     * Expands a set of seed nodes into a community.
-     *
-     * @param[in] s The seed nodes
-     * @return A community of the seed nodes
-     */
-    std::set<node> expandOneCommunity(const std::set<node> &s) override;
-
-    using SelectiveCommunityDetector::expandOneCommunity;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_SCD_LOCAL_T_HPP_

package/vendor/include/networkit/scd/LocalTightnessExpansion.hpp

@@ -1,46 +0,0 @@
-#ifndef NETWORKIT_SCD_LOCAL_TIGHTNESS_EXPANSION_HPP_
-#define NETWORKIT_SCD_LOCAL_TIGHTNESS_EXPANSION_HPP_
-
-#include <networkit/scd/SelectiveCommunityDetector.hpp>
-
-namespace NetworKit {
-
-/**
- * The Local Tightness Expansion (LTE) algorithm.
- *
- * The algorithm can handle weighted graphs.
- *
- * This is the local community expansion algorithm described in
- *
- * Huang, J., Sun, H., Liu, Y., Song, Q., & Weninger, T. (2011).
- * Towards Online Multiresolution Community Detection in Large-Scale Networks.
- * PLOS ONE, 6(8), e23829.
- * https://doi.org/10.1371/journal.pone.0023829
- */
-class LocalTightnessExpansion : public SelectiveCommunityDetector {
-private:
-    double alpha;
-
-public:
-    /**
-     * Constructs the Local Tightness Expansion algorithm.
-     *
-     * @param[in] G The graph to detect communities on
-     * @param[in] alpha Tightness coefficient - smaller values lead to larger communities
-     */
-    LocalTightnessExpansion(const Graph &g, double alpha = 1.0);
-
-    /**
-     * Expands a set of seed nodes into a community.
-     *
-     * @param[in] s The seed nodes
-     * @return A community of the seed nodes
-     */
-    std::set<node> expandOneCommunity(const std::set<node> &s) override;
-
-    using SelectiveCommunityDetector::expandOneCommunity;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_SCD_LOCAL_TIGHTNESS_EXPANSION_HPP_

package/vendor/include/networkit/scd/PageRankNibble.hpp

@@ -1,55 +0,0 @@
-/*
- * PageRankNibble.hpp
- *
- *  Created on: 26.02.2014
- *      Author: Henning
- */
-
-#ifndef NETWORKIT_SCD_PAGE_RANK_NIBBLE_HPP_
-#define NETWORKIT_SCD_PAGE_RANK_NIBBLE_HPP_
-
-#include <set>
-
-#include <networkit/graph/Graph.hpp>
-#include <networkit/scd/SelectiveCommunityDetector.hpp>
-
-namespace NetworKit {
-
-/**
- * Variant of PageRank-Nibble algorithm due to Andersen, Chung and Lang.
- * Paper: Local Graph Partitioning using PageRank Vectors.
- * URL: http://www.math.ucsd.edu/~fan/wp/localpartition.pdf
- * Simplifications according to D. Gleich's code at URL https://gist.github.com/dgleich/6201856.
- */
-class PageRankNibble final : public SelectiveCommunityDetector {
-
-    double alpha;
-    double epsilon;
-
-    std::set<node> bestSweepSet(std::vector<std::pair<node, double>> &pr);
-
-public:
-    /**
-     * @param Graph @a g for which PageRank-Nibble is to be performed. Is treated as
-     * unweighted in current implementation.
-     * @param alpha Loop probability of random walk; smaller values tend to produce larger
-     *        communities.
-     * @param eps Tolerance threshold for approximation of PageRank vectors.
-     */
-    PageRankNibble(const Graph &g, double alpha, double epsilon);
-
-    ~PageRankNibble() override = default;
-
-    /**
-     * @param seeds Seed nodes for which a community is to be found.
-     *
-     * @return Set of nodes that makes up the best community found around the @a seeds nodes.
-     */
-    std::set<node> expandOneCommunity(const std::set<node> &seeds) override;
-
-    // inherit method from parent class.
-    using SelectiveCommunityDetector::expandOneCommunity;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_SCD_PAGE_RANK_NIBBLE_HPP_

package/vendor/include/networkit/scd/RandomBFS.hpp

@@ -1,33 +0,0 @@
-#ifndef NETWORKIT_SCD_RANDOM_BFS_HPP_
-#define NETWORKIT_SCD_RANDOM_BFS_HPP_
-
-#include <networkit/scd/SelectiveCommunityDetector.hpp>
-#include <networkit/structures/Cover.hpp>
-
-namespace NetworKit {
-
-/*
- * The random BFS community detection baseline:
- * finds a community around a seed node with a given size using a prefix of a
- * BFS order that is selected at random among all possible prefixes.
- */
-class RandomBFS : public SelectiveCommunityDetector {
-
-public:
-    RandomBFS(const Graph &g, const Cover &c);
-
-    /**
-     * @param[in]	s	seed node
-     *
-     * @param[out]		community as a set of nodes
-     */
-    std::set<node> expandOneCommunity(const std::set<node> &s) override;
-    using SelectiveCommunityDetector::expandOneCommunity;
-
-protected:
-    const Cover *c; // ground truth communities
-    std::map<index, count> subsetSizes;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_SCD_RANDOM_BFS_HPP_

package/vendor/include/networkit/scd/SCDGroundTruthComparison.hpp

@@ -1,121 +0,0 @@
-#ifndef NETWORKIT_SCD_SCD_GROUND_TRUTH_COMPARISON_HPP_
-#define NETWORKIT_SCD_SCD_GROUND_TRUTH_COMPARISON_HPP_
-
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/graph/Graph.hpp>
-#include <networkit/structures/Cover.hpp>
-
-#include <map>
-#include <set>
-
-namespace NetworKit {
-
-/**
- * This class evaluates a set found communities against a ground truth cover. Each found community
- * is compared against the communities of the seed node in the ground truth cover.
- *
- * For each score, the ground truth community is chosen as comparison that maximizes the score.
- * If seeds are not ignored (a parameter of the constructor), then only ground truth communities
- * that contain the given seed are used to compare against.
- *
- * The calculated scores are:
- *
- * Precision: the size of the intersection of found and ground truth community divided by the
- * size of the found community, i.e., how much of the found community was an actual match.
- *
- * Recall: the size of the intersection of found and ground truth community divided by the
- * size of the ground truth community, i.e., how much of the ground truth community was found.
- *
- * F1 score: the harmonic mean of precision and recall.
- *
- * Jaccard index: the size of the intersection of found and ground truth community divided by the
- * size of the union of found and ground truth community.
- *
- * For each score, the range of values is between 0 and 1, where 0 is the worst and 1 the best
- * score.
- */
-class SCDGroundTruthComparison final : public Algorithm {
-public:
-    /**
-     * Construct the SCD evaluation for the given graph, ground truth and found communities.
-     *
-     * @param G The graph to compare on
-     * @param groundTruth The ground truth cover
-     * @param found The found communities
-     * @param ignoreSeeds If the seeds shall be ignored, i.e. any ground truth community is a match
-     */
-    SCDGroundTruthComparison(const Graph &g, const Cover &groundTruth,
-                             const std::map<node, std::set<node>> &found, bool ignoreSeeds = false);
-
-    /**
-     * Calculate all measures.
-     */
-    void run() override;
-
-    /**
-     * Get the Jaccard index of every found community.
-     *
-     * @return A map between seed node and the jaccard index of the seed's community.
-     */
-    const std::map<index, double> &getIndividualJaccard() const;
-
-    /**
-     * Get the precision of every found community.
-     *
-     * @return A map between seed node and the precision of the seed's community.
-     */
-    const std::map<index, double> &getIndividualPrecision() const;
-
-    /**
-     * Get the recall of every found community.
-     *
-     * @return A map between seed node and the recall of the seed's community.
-     */
-    const std::map<index, double> &getIndividualRecall() const;
-
-    /**
-     * Get the F1 score of every found community.
-     *
-     * @return A map between seed node and the F1 score of the seed's community.
-     */
-    const std::map<index, double> &getIndividualF1() const;
-
-    /**
-     * Get the (unweighted) average of the jaccard indices of every found community.
-     */
-    double getAverageJaccard() const;
-
-    /**
-     * Get the (unweighted) average of the F1 score of every found community.
-     */
-    double getAverageF1() const;
-
-    /**
-     * Get the (unweighted) average of the precision of every found community.
-     */
-    double getAveragePrecision() const;
-
-    /**
-     * Get the (unweighted) average of the recall of every found community.
-     */
-    double getAverageRecall() const;
-
-private:
-    const Graph *g;
-    const Cover *groundTruth;
-    const std::map<node, std::set<node>> *found;
-    bool ignoreSeeds;
-
-    std::map<index, double> jaccardScores;
-    double averageJaccard;
-    std::map<index, double> f1Scores;
-    double averageF1;
-    std::map<index, double> precisionScores;
-    double averagePrecision;
-    std::map<index, double> recallScores;
-    double averageRecall;
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_SCD_SCD_GROUND_TRUTH_COMPARISON_HPP_

package/vendor/include/networkit/scd/SelectiveCommunityDetector.hpp

@@ -1,76 +0,0 @@
-/*
- * SelectiveCommunityDetector.hpp
- *
- *  Created on: 15.05.2013
- *      Author: cls
- */
-
-#ifndef NETWORKIT_SCD_SELECTIVE_COMMUNITY_DETECTOR_HPP_
-#define NETWORKIT_SCD_SELECTIVE_COMMUNITY_DETECTOR_HPP_
-
-#include <map>
-#include <set>
-
-#include <networkit/auxiliary/Timer.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * Base class for selective community detection algorithms, i.e., algorithms
- * that detect communities around a single node.
- */
-class SelectiveCommunityDetector {
-
-public:
-    /**
-     * Construct a selective community detector. This should only be called by child classes.
-     *
-     * @param G The graph for which communities shall be detected.
-     */
-    SelectiveCommunityDetector(const Graph &g);
-
-    /**
-     * Virtual default destructor to allow safe destruction of child classes.
-     */
-    virtual ~SelectiveCommunityDetector() = default;
-
-    /**
-     * Detect one community for each of the given seed nodes.
-     *
-     * The default implementation calls expandOneCommunity() for each of the seeds.
-     *
-     * @param seeds The list of seeds for which communities shall be detected.
-     * @return a mapping from seed node to community (as a set of nodes)
-     */
-    virtual std::map<node, std::set<node>> run(const std::set<node> &seeds);
-
-    /**
-     * Detect a community for the given seed node.
-     *
-     * The default implementation calls expandOneCommunity(const
-     * std::set<node>&) with a set of one node.
-     *
-     * @param seed The seed to find the community for.
-     * @return The found community as set of node.
-     */
-    virtual std::set<node> expandOneCommunity(node seed);
-
-    /**
-     * Detect a single community for the given seed nodes.
-     *
-     * This is useful if you know multiple nodes that should be part of the
-     * community. This method may throw an exception if the particular algorithm
-     * does not support multiple seeds.
-     *
-     * @param seeds The seeds for the community.
-     * @return The found community as set of nodes.
-     */
-    virtual std::set<node> expandOneCommunity(const std::set<node> &seeds) = 0;
-
-protected:
-    const Graph *g;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_SCD_SELECTIVE_COMMUNITY_DETECTOR_HPP_

package/vendor/include/networkit/scd/SetConductance.hpp

@@ -1,47 +0,0 @@
-#ifndef NETWORKIT_SCD_SET_CONDUCTANCE_HPP_
-#define NETWORKIT_SCD_SET_CONDUCTANCE_HPP_
-
-#include <set>
-
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * Calculates the conductance of a set of nodes, i.e., the weight of all edges
- * between the set and the rest of the graph divided by the minimum
- * of the volume (the sum of the weighted degrees) of the community and the rest
- * of the graph.
- */
-class SetConductance : public Algorithm {
-public:
-    /**
-     * Construct the SetConductance with the given graph and community.
-     *
-     * @param G The graph
-     * @param community The set of nodes to examine.
-     */
-    SetConductance(const Graph &g, const std::set<node> &community);
-
-    /**
-     * Calculate the conductance.
-     */
-    void run() override;
-
-    /**
-     * Get the calculated conductance score.
-     *
-     * @return The conductance.
-     */
-    double getConductance() const;
-
-private:
-    const Graph *g;
-    const std::set<node> *community;
-    double conductance;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_SCD_SET_CONDUCTANCE_HPP_

package/vendor/include/networkit/scd/TCE.hpp

@@ -1,41 +0,0 @@
-#ifndef NETWORKIT_SCD_TCE_HPP_
-#define NETWORKIT_SCD_TCE_HPP_
-
-#include <networkit/scd/SelectiveCommunityDetector.hpp>
-
-namespace NetworKit {
-
-/**
- * Triangle-based community expansion
- *
- * The algorithm can handle weighted graphs.
- */
-class TCE : public SelectiveCommunityDetector {
-private:
-    bool refine;
-    bool useJaccard;
-
-public:
-    /**
-     * Construct a TCE object.
-     *
-     * @param[in] G The graph to detect communities on
-     * @param[in] refine If nodes shall be removed again if this makes the community better
-     * @param[in] useJaccard use jaccard index for weight calculation.
-     */
-    TCE(const Graph &g, bool refine = false, bool useJaccard = false);
-
-    /**
-     * Expands a set of seed nodes into a community.
-     *
-     * @param[in] s The seed nodes
-     * @return A community of the seed nodes
-     */
-    std::set<node> expandOneCommunity(const std::set<node> &s) override;
-
-    using SelectiveCommunityDetector::expandOneCommunity;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_SCD_TCE_HPP_

package/vendor/include/networkit/scd/TwoPhaseL.hpp

@@ -1,40 +0,0 @@
-#ifndef NETWORKIT_SCD_TWO_PHASE_L_HPP_
-#define NETWORKIT_SCD_TWO_PHASE_L_HPP_
-
-#include <networkit/scd/SelectiveCommunityDetector.hpp>
-
-namespace NetworKit {
-
-/**
- * The two-phase local community detection algorithm optimizing the L-measure.
- *
- * This is an implementation of the algorithm proposed in:
- *
- * Chen, J., Zaïane, O., & Goebel, R. (2009).
- * Local Community Identification in Social Networks.
- * In 2009 International Conference on Advances in Social Network Analysis and Mining (pp. 237–242).
- * https://doi.org/10.1109/ASONAM.2009.14
- */
-class TwoPhaseL : public SelectiveCommunityDetector {
-
-public:
-    /**
-     * Construct the algorithm class.
-     *
-     * @param G The graph on which communities shall be found.
-     */
-    TwoPhaseL(const Graph &g);
-
-    /**
-     * @param[in]	seeds	seed nodes
-     *
-     * @param[out]		community as a set of nodes
-     */
-    std::set<node> expandOneCommunity(const std::set<node> &s) override;
-
-    // inherit method from parent class.
-    using SelectiveCommunityDetector::expandOneCommunity;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_SCD_TWO_PHASE_L_HPP_

package/vendor/include/networkit/scoring/EdgeScoring.hpp

@@ -1,44 +0,0 @@
-/*
- * EdgeScoring.hpp
- *
- *  Created on: 15.10.2012
- *      Author: Christian Staudt
- */
-
-#ifndef NETWORKIT_SCORING_EDGE_SCORING_HPP_
-#define NETWORKIT_SCORING_EDGE_SCORING_HPP_
-
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup scoring
- * Abstract base class for algorithms associating a score with an edge.
- */
-template <typename T>
-class EdgeScoring {
-
-protected:
-    Graph *G;
-
-public:
-    EdgeScoring(Graph &G);
-
-    virtual ~EdgeScoring();
-
-    virtual void scoreEdges(int attrId) = 0;
-
-    virtual T edgeScore(node u, node v) const = 0;
-};
-
-template <typename T>
-EdgeScoring<T>::EdgeScoring(Graph &G) {
-    this->G = &G;
-}
-
-template <typename T>
-EdgeScoring<T>::~EdgeScoring() {}
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_SCORING_EDGE_SCORING_HPP_