@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,79 @@
+/*
+ * ModularityScoring.hpp
+ *
+ *  Created on: 15.10.2012
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_SCORING_MODULARITY_SCORING_HPP_
+#define NETWORKIT_SCORING_MODULARITY_SCORING_HPP_
+
+#include <networkit/scoring/EdgeScoring.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+// TODO: implement modularity as in Python prototype
+
+/**
+ * @ingroup scoring
+ */
+template <typename T>
+class ModularityScoring final : public EdgeScoring<T> {
+
+    double totalEdgeWeight; //!< total weight of the graph
+
+public:
+    /**
+     * @param[in]  G  a graph instance
+     *
+     * Do not modify the graph while using this instance of ModularityScoring.
+     */
+    ModularityScoring(Graph &G, double gTotalEdgeWeight = 0.0);
+
+    /** Default destructor */
+    ~ModularityScoring() override = default;
+
+    void scoreEdges(int attrId) override;
+
+    /**
+     * Returns an edge score for an edge (u,v) which expresses the
+     * modularity increase which can be gained by merging
+     * the clusters of u and v.
+     *
+     * $$\\Delta mod(c, d) := \\frac{1}{2 \\omega(E)} \\left ( 2 \\omega(E) \\omega(c,d) -
+     * \\omega(c) \\omega(d) \\right ) $$
+     *
+     * @param[in]  u  source node id
+     * @param[out]  v  target node id
+     *
+     */
+    T edgeScore(node u, node v) const override;
+};
+
+template <typename T>
+ModularityScoring<T>::ModularityScoring(Graph &G, double gTotalEdgeWeight)
+    : EdgeScoring<T>(G), totalEdgeWeight(gTotalEdgeWeight) {
+    if (gTotalEdgeWeight == 0.0) {
+        this->totalEdgeWeight = this->G->totalEdgeWeight();
+    }
+}
+
+template <typename T>
+inline T ModularityScoring<T>::edgeScore(node u, node v) const {
+    assert(totalEdgeWeight != 0.0);
+    double volume = 2.0 * totalEdgeWeight;
+    double nom1 = (this->G->weightedDegree(u) / volume);
+    double nom2 = (this->G->weightedDegree(v) / volume);
+    double deltaMod = (this->G->weight(u, v) / totalEdgeWeight) - (nom1 * nom2);
+    return deltaMod;
+}
+
+template <typename T>
+void ModularityScoring<T>::scoreEdges(int) {
+    // TODO: rewrite with new edge attribute system
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_SCORING_MODULARITY_SCORING_HPP_

package/vendor/include/networkit/simulation/EpidemicSimulationSEIR.hpp

@@ -0,0 +1,59 @@
+/*
+ * EpidemicSimulationSEIR.hpp
+ *
+ *  Created on: 20.11.2015
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_SIMULATION_EPIDEMIC_SIMULATION_SEIR_HPP_
+#define NETWORKIT_SIMULATION_EPIDEMIC_SIMULATION_SEIR_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup simulation
+ * Node centrality index which ranks nodes by their degree.
+ * Optional normalization by maximum degree.
+ */
+class EpidemicSimulationSEIR final : public Algorithm {
+public:
+    /**
+     * Simulates an epidemic spread using the Susceptible-Exposed-Infectious-Removed (SEIR) model.
+     * @param G The network.
+     * @param tMax Max. number of timesteps.
+     * @param transP Transmission probability.
+     * @param eTime Exposed time.
+     * @param iTime Infectious time.
+     * @param zero Starting node.
+     */
+    EpidemicSimulationSEIR(const Graph &G, count tMax, double transP, count eTime, count iTime,
+                           node zero);
+
+    void run() override;
+
+    /**
+     * Returns the data from the simulation (only valid after run() was called).
+     * @return Vector of vectors, containing "zero", "time", "state" and "count" values for each
+     * node.
+     */
+    const std::vector<std::vector<count>> &getData() const;
+
+private:
+    const Graph *G;
+    count tMax;
+    double transP;
+    count eTime;
+    count iTime;
+    node zero;
+    enum class State { S, E, I, R, U }; // Susceptible, Exposed, Infectious, Removed, Undefined
+    std::vector<State> state;
+    std::vector<index> timestamp;
+    std::vector<std::vector<count>> stats;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_SIMULATION_EPIDEMIC_SIMULATION_SEIR_HPP_

package/vendor/include/networkit/sparsification/ChanceCorrectedTriangleScore.hpp

@@ -0,0 +1,28 @@
+/*
+ * ChangeCorrectedTriangleScore.hpp
+ *
+ *  Created on: 20.11.2014
+ *      Author: Michael Hamann
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_CHANCE_CORRECTED_TRIANGLE_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_CHANCE_CORRECTED_TRIANGLE_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+class ChanceCorrectedTriangleScore final : public EdgeScore<double> {
+
+public:
+    ChanceCorrectedTriangleScore(const Graph &graph, const std::vector<count> &triangles);
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+    void run() override;
+
+private:
+    const std::vector<count> *triangles;
+};
+
+} // namespace NetworKit
+#endif // NETWORKIT_SPARSIFICATION_CHANCE_CORRECTED_TRIANGLE_SCORE_HPP_

package/vendor/include/networkit/sparsification/ForestFireScore.hpp

@@ -0,0 +1,34 @@
+/*
+ * ForestFireScore.hpp
+ *
+ *  Created on: 26.08.2014
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_FOREST_FIRE_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_FOREST_FIRE_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+/**
+ * Based on the Forest Fire algorithm introduced by Leskovec et al.
+ * The burn frequency of the edges is used as edge score.
+ */
+class ForestFireScore final : public EdgeScore<double> {
+
+public:
+    ForestFireScore(const Graph &graph, double pf, double targetBurntRatio);
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+    void run() override;
+
+private:
+    double pf;
+    double targetBurntRatio;
+};
+
+} // namespace NetworKit
+/* namespace NetworKit */
+#endif // NETWORKIT_SPARSIFICATION_FOREST_FIRE_SCORE_HPP_

package/vendor/include/networkit/sparsification/GlobalThresholdFilter.hpp

@@ -0,0 +1,40 @@
+/*
+ * GlobalThresholdFilter.hpp
+ *
+ *  Created on: 23.07.2014
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_GLOBAL_THRESHOLD_FILTER_HPP_
+#define NETWORKIT_SPARSIFICATION_GLOBAL_THRESHOLD_FILTER_HPP_
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * Calculates a sparsified graph by applying a global threshold to an edge score.
+ */
+class GlobalThresholdFilter {
+    const Graph *graph;
+    const std::vector<double> &attribute;
+    const double threshold;
+    const bool above;
+
+public:
+    /**
+     * Creates a new instance of a global threshold filter.
+     * @param threshold the threshold
+     * @param above if set to true, edges with a score above or equal to the threshold remain in
+     * the filtered graph. If set to false, edges with a score below or equal to the threshold
+     * remain in the filtered graph.
+     */
+    GlobalThresholdFilter(const Graph &graph, const std::vector<double> &attribute,
+                          double threshold, bool above);
+
+    GraphW calculate();
+    GraphW calculateUndirected();
+};
+
+} // namespace NetworKit
+#endif // NETWORKIT_SPARSIFICATION_GLOBAL_THRESHOLD_FILTER_HPP_

package/vendor/include/networkit/sparsification/LocalDegreeScore.hpp

@@ -0,0 +1,30 @@
+/*
+ * LocalDegreeScore.hpp
+ *
+ *  Created on: 28.08.2014
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_LOCAL_DEGREE_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_LOCAL_DEGREE_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+/**
+ * Local Degree sparsification method.
+ * See 'Structure-Preserving Sparsification of Social Networks' by Lindner, Staudt, Hamann.
+ */
+class LocalDegreeScore final : public EdgeScore<double> {
+
+public:
+    LocalDegreeScore(const Graph &G);
+    void run() override;
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+};
+
+} // namespace NetworKit
+/* namespace NetworKit */
+#endif // NETWORKIT_SPARSIFICATION_LOCAL_DEGREE_SCORE_HPP_

package/vendor/include/networkit/sparsification/LocalFilterScore.hpp

@@ -0,0 +1,124 @@
+/*
+ * LocalFilterScore.hpp
+ *
+ *  Created on: 20.11.2014
+ *      Author: Michael Hamann, Gerd Lindner
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_LOCAL_FILTER_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_LOCAL_FILTER_SCORE_HPP_
+
+#include <atomic>
+#include <memory>
+
+#include <networkit/auxiliary/Parallel.hpp>
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+/**
+ * Local filtering edge scoring. Edges with high score are more important.
+ *
+ * Edges are ranked locally, the top d^e (logarithmic, default) or 1+e*(d-1) edges (non-logarithmic)
+ * are kept. For equal attribute values, neighbors of low degree are preferred.
+ */
+template <typename InType>
+class LocalFilterScore final : public EdgeScore<double> {
+
+public:
+    /**
+     * Initialize the local edge filtering score.
+     *
+     * @param G The graph for which the score shall be.
+     * @param attribute The input attribute according to which the edges shall be filtered locally.
+     * @param logarithmic If the score shall be logarithmic in the rank (then d^e edges are kept).
+     * Linear otherwise.
+     */
+    LocalFilterScore(const Graph &G, const std::vector<InType> &attribute, bool logarithmic = true)
+        : EdgeScore<double>(G), attribute(&attribute), logarithmic(logarithmic) {}
+
+    /**
+     * Execute the algorithm.
+     */
+    void run() override {
+        if (!G->hasEdgeIds()) {
+            throw std::runtime_error("edges have not been indexed - call indexEdges first");
+        }
+
+        /*
+         * For each edge, we calculate the minimum required sparsification exponent e
+         * such that the edge is contained in the sparse graph.
+         */
+
+        std::unique_ptr<std::atomic<double>[]> sparsificationExp(
+            new std::atomic<double>[G->upperEdgeIdBound()] {});
+
+        G->balancedParallelForNodes([&](node i) {
+            count d = G->degree(i);
+
+            /*
+             * The top d^e edges (sorted by similarity in descending order)
+             * are to be kept in the sparse graph.
+             */
+
+            std::vector<edgeid> neighbors;
+            neighbors.reserve(d);
+            G->forNeighborsOf(i, [&](node _i, node j, edgeid eid) { neighbors.emplace_back(eid); });
+
+            std::sort(neighbors.begin(), neighbors.end(), [&](const edgeid &e1, const edgeid &e2) {
+                return (*attribute)[e1] > (*attribute)[e2];
+            });
+
+            count rank = 0;
+            count numSame = 1;
+            InType oldValue = std::numeric_limits<InType>::lowest();
+
+            for (edgeid eid : neighbors) {
+                if ((*attribute)[eid] != oldValue) {
+                    rank += numSame;
+                    numSame = 1;
+                } else {
+                    ++numSame;
+                }
+
+                double e = 1.0;
+
+                if (d > 1) {
+                    if (logarithmic) {
+                        e = 1.0 - log(rank) / log(d);
+                    } else {
+                        e = 1.0 - (rank - 1) * 1.0 / (d - 1); // Keep top 1 + e * (d-1) edges
+                    }
+                }
+
+                Aux::Parallel::atomic_max(sparsificationExp[eid], e);
+            }
+        });
+
+        scoreData.clear();
+        scoreData.resize(G->upperEdgeIdBound());
+
+#pragma omp parallel for
+        for (omp_index i = 0; i < static_cast<omp_index>(scoreData.size()); ++i) {
+            scoreData[i] = sparsificationExp[i];
+        }
+
+        hasRun = true;
+    }
+
+    double score(node u, node v) override {
+        throw std::runtime_error("Not implemented: Use scores() instead.");
+    }
+
+    double score(edgeid eid) override {
+        throw std::runtime_error("Not implemented: Use scores() instead.");
+    }
+
+private:
+    const std::vector<InType> *attribute;
+    bool logarithmic;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_SPARSIFICATION_LOCAL_FILTER_SCORE_HPP_

package/vendor/include/networkit/sparsification/LocalSimilarityScore.hpp

@@ -0,0 +1,63 @@
+/*
+ * LocalSimilarityScore.hpp
+ *
+ *  Created on: 26.07.2014
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_LOCAL_SIMILARITY_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_LOCAL_SIMILARITY_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+template <typename T>
+struct AttributizedEdge {
+    node ego;
+    node alter;
+    edgeid eid;
+    T value;
+
+    AttributizedEdge(node ego, node alter, edgeid eid, T v)
+        : ego(ego), alter(alter), eid(eid), value(v) {}
+
+    bool operator<(const AttributizedEdge<T> &other) const {
+        return (value > other.value) || (value == other.value && alter < other.alter);
+    }
+
+    bool operator>(const AttributizedEdge<T> &other) const {
+        return (value < other.value) || (value == other.value && alter > other.alter);
+    }
+
+    bool operator==(const AttributizedEdge<T> &other) const {
+        return ego == other.ego && alter == other.alter && value == other.value;
+    }
+};
+
+struct greater {
+    template <class T>
+    bool operator()(T const &a, T const &b) const {
+        return a > b;
+    }
+};
+
+/**
+ * Implementation of the Local Sparsification Algorithm by Sataluri et al.
+ */
+class LocalSimilarityScore final : public EdgeScore<double> {
+
+public:
+    LocalSimilarityScore(const Graph &G, const std::vector<count> &triangles);
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+    void run() override;
+
+private:
+    const std::vector<count> *triangles;
+};
+
+} // namespace NetworKit
+/* namespace NetworKit */
+
+#endif // NETWORKIT_SPARSIFICATION_LOCAL_SIMILARITY_SCORE_HPP_

package/vendor/include/networkit/sparsification/MultiscaleScore.hpp

@@ -0,0 +1,38 @@
+/*
+ * MultiscaleScore.hpp
+ *
+ *  Created on: 20.06.2014
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_MULTISCALE_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_MULTISCALE_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+/**
+ * Calculates the multiscale edge score for a given graph. Each edge is
+ * assigned the maximum filter value in [0,1] for which the edge will be contained
+ * in the multiscale backbone.
+ *
+ * See "Extracting the multiscale backbone of complex weighted networks" by Serrano et al.
+ */
+class MultiscaleScore final : public EdgeScore<double> {
+
+public:
+    MultiscaleScore(const Graph &graph, const std::vector<double> &attribute);
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+    void run() override;
+    double getProbability(count degree, edgeweight normalizedWeight);
+
+private:
+    const std::vector<double> *attribute;
+};
+
+} // namespace NetworKit
+/* namespace NetworKit */
+
+#endif // NETWORKIT_SPARSIFICATION_MULTISCALE_SCORE_HPP_

package/vendor/include/networkit/sparsification/RandomEdgeScore.hpp

@@ -0,0 +1,33 @@
+/*
+ * RandomEdgeScore.hpp
+ *
+ *  Created on: 11.08.2014
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_RANDOM_EDGE_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_RANDOM_EDGE_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+/**
+ * Generates a random edge attribute. Each edge is assigned a random value in [0,1].
+ */
+class RandomEdgeScore final : public EdgeScore<double> {
+
+public:
+    /**
+     * Creates a new instance of the Random edge score.
+     */
+    RandomEdgeScore(const Graph &G);
+
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+    void run() override;
+};
+
+} // namespace NetworKit
+/* namespace NetworKit */
+#endif // NETWORKIT_SPARSIFICATION_RANDOM_EDGE_SCORE_HPP_

package/vendor/include/networkit/sparsification/RandomNodeEdgeScore.hpp

@@ -0,0 +1,29 @@
+/*
+ * RandomNodeEdgeScore.hpp
+ *
+ *  Created on: 20.11.2014
+ *      Author: Michael Hamann
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_RANDOM_NODE_EDGE_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_RANDOM_NODE_EDGE_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+class RandomNodeEdgeScore final : public EdgeScore<double> {
+
+public:
+    RandomNodeEdgeScore(const Graph &graph, double rneRatio = 0.8);
+    void run() override;
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+
+private:
+    double rneRatio;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_SPARSIFICATION_RANDOM_NODE_EDGE_SCORE_HPP_

package/vendor/include/networkit/sparsification/SCANStructuralSimilarityScore.hpp

@@ -0,0 +1,23 @@
+
+#ifndef NETWORKIT_SPARSIFICATION_SCAN_STRUCTURAL_SIMILARITY_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_SCAN_STRUCTURAL_SIMILARITY_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+class SCANStructuralSimilarityScore final : public EdgeScore<double> {
+
+public:
+    SCANStructuralSimilarityScore(const Graph &G, const std::vector<count> &triangles);
+    void run() override;
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+
+private:
+    const std::vector<count> *triangles;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_SPARSIFICATION_SCAN_STRUCTURAL_SIMILARITY_SCORE_HPP_

package/vendor/include/networkit/sparsification/SimmelianOverlapScore.hpp

@@ -0,0 +1,35 @@
+/*
+ * SimmelianOverlapScore.hpp
+ *
+ *  Created on: 22.07.2014
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_SIMMELIAN_OVERLAP_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_SIMMELIAN_OVERLAP_SCORE_HPP_
+
+#include <set>
+#include <networkit/sparsification/SimmelianScore.hpp>
+
+namespace NetworKit {
+
+/**
+ * Calculates the Simmelian backbone (paramaetric variant) for a given input graph.
+ */
+class SimmelianOverlapScore final : public SimmelianScore {
+
+public:
+    /**
+     * Creates a new instance of the parametric variant of the Simmelian Backbone calculator.
+     * @param maxRank     the maximum rank that is considered for overlap calculation
+     */
+    SimmelianOverlapScore(const Graph &graph, const std::vector<count> &triangles, count maxRank);
+    void run() override;
+
+private:
+    count maxRank;
+};
+
+} // namespace NetworKit
+/* namespace NetworKit */
+#endif // NETWORKIT_SPARSIFICATION_SIMMELIAN_OVERLAP_SCORE_HPP_