@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,92 @@
+/*
+ * SimmelianAttributizer.hpp
+ *
+ *  Created on: 21.05.2014
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_SIMMELIAN_SCORE_HPP_
+#define NETWORKIT_SPARSIFICATION_SIMMELIAN_SCORE_HPP_
+
+#include <set>
+#include <unordered_set>
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+/**
+ * A directed edge with a simmelianness int value.
+ * An ordering is defined on these ties: We order first by
+ * simmelianness (descending) and then by the id of alter (ascending).
+ */
+struct RankedEdge {
+    node ego;
+    node alter;
+    count simmelianness; // The number of triangles the edge is embedded in.
+    count rank;          // The rank within the ranked neighborhood.
+
+    RankedEdge(node ego, node alter, count s) : ego(ego), alter(alter), simmelianness(s), rank(0) {}
+
+    RankedEdge(node ego, node alter, count s, count r)
+        : ego(ego), alter(alter), simmelianness(s), rank(r) {}
+
+    bool operator<(const RankedEdge &other) const {
+        return (simmelianness > other.simmelianness)
+               || (simmelianness == other.simmelianness && alter > other.alter);
+    }
+
+    bool operator>(const RankedEdge &other) const {
+        return (simmelianness < other.simmelianness)
+               || (simmelianness == other.simmelianness && alter < other.alter);
+    }
+
+    bool operator==(const RankedEdge &other) const {
+        return ego == other.ego && simmelianness == other.simmelianness && alter == other.alter
+               && rank == other.rank;
+    }
+};
+
+using RankedNeighbors = std::vector<RankedEdge>;
+
+/**
+ * Represents the result of the comparison of two ranked neighborhood lists, namely
+ * the overlap of the top-k neighbors and the maximum jaccard index.
+ */
+struct Redundancy {
+    count overlap;
+    double jaccard;
+
+    Redundancy(count o, double j) : overlap(o), jaccard(j) {}
+};
+
+/**
+ * Abstract base class for the two variants of Simmelian backbones (OverlapFilter, JaccardFilter).
+ */
+class SimmelianScore : public EdgeScore<double> {
+
+public:
+    SimmelianScore(const Graph &graph, const std::vector<count> &attribute);
+    double score(edgeid eid) override;
+    double score(node u, node v) override;
+
+    std::vector<RankedNeighbors> getRankedNeighborhood(const Graph &g,
+                                                       const std::vector<count> &triangles);
+
+    Redundancy getOverlap(const node &ego, const node &alter,
+                          const std::vector<RankedNeighbors> &neighbors, const count &maxRank);
+
+protected:
+    const std::vector<count> *triangles;
+
+    void matchNeighbors(node ego, node alter, bool reciprocityCheck,
+                        std::vector<RankedEdge>::const_iterator &egoIt,
+                        const RankedNeighbors &egoNeighbors,
+                        std::unordered_set<node> &egoNeighborsUnmatched,
+                        std::unordered_set<node> &alterNeighborsUnmatched, count rank,
+                        count &overlap);
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_SPARSIFICATION_SIMMELIAN_SCORE_HPP_

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

@@ -0,0 +1,166 @@
+/*
+ * Sparsifiers.hpp
+ *
+ *  Created on: 23.07.2014
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_SPARSIFICATION_SPARSIFIERS_HPP_
+#define NETWORKIT_SPARSIFICATION_SPARSIFIERS_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * In this file, edge score calculators and edge score filters are combined
+ * into different sparsification algorithms.
+ */
+
+/**
+ * Abstract base class for Sparsifiers.
+ */
+class Sparsifier {
+
+public:
+    Sparsifier(const Graph &inputGraph);
+
+    virtual ~Sparsifier() = default;
+
+    /**
+     * REQ: Needs to fill outputGraph and set hasOutput to true.
+     */
+    virtual void run() = 0;
+
+    GraphW getGraph();
+
+protected:
+    const Graph &inputGraph;
+    GraphW outputGraph;
+    bool hasOutput;
+};
+
+/**
+ * Imlementation of the non-parametric variant of Simmelian Backbones,
+ * as introduced by Nick et al.
+ */
+class SimmelianSparsifierNonParametric : public Sparsifier {
+
+public:
+    /**
+     * Creates a new instance of the non-parametric (jaccard) variant of the Simmelian Backbone
+     * calculator.
+     * @param graph			the input graph
+     * @param threshold		the jaccard index threshold.
+     */
+    SimmelianSparsifierNonParametric(const Graph &graph, double threshold);
+
+    void run() override;
+
+private:
+    double threshold;
+};
+
+/**
+ * Imlementation of the parametric variant (Top-k neighborhood overlap)
+ * of Simmelian Backbones, as introduced by Nick et al.
+ */
+class SimmelianSparsifierParametric : public Sparsifier {
+
+public:
+    /**
+     * Creates a new instance of the parametric variant of the Simmelian Backbone calculator.
+     * @param graph			the input graph
+     * @param maxRank 		the maximum rank that is considered for overlap calculation
+     * @param minOverlap	the minimum overlap of the top-k neighbors for an edge to be
+                                contained in the sparsified graph.
+     */
+    SimmelianSparsifierParametric(const Graph &graph, int maxRank, int minOverlap);
+
+    void run() override;
+
+private:
+    int maxRank;
+    int minOverlap;
+};
+
+/**
+ * Implementation of the Multiscale Backbone, as introduced by Serrano et al.
+ */
+class MultiscaleSparsifier : public Sparsifier {
+
+public:
+    /**
+     * Creates a new instance of the Multiscale Backbone calculator.
+     * @param graph			the input graph
+     * @param alpha 		the probability threshold
+     */
+    MultiscaleSparsifier(const Graph &graph, double alpha);
+
+    void run() override;
+
+private:
+    double alpha;
+};
+
+/**
+ * Local Similarity Sparsification as introduced by Satuluri et al.
+ */
+class LocalSimilaritySparsifier : public Sparsifier {
+
+public:
+    /**
+     * Creates a new instance of the Local Similarity sparsifier.
+     * @param graph			the input graph
+     * @param e				the threshold value
+     */
+    LocalSimilaritySparsifier(const Graph &graph, double e);
+
+    void run() override;
+
+private:
+    double e;
+};
+
+/**
+ * Multiscale backbone using simmelianness as input weight.
+ */
+class SimmelianMultiscaleSparsifier : public Sparsifier {
+
+public:
+    /**
+     * Creates a new instance of the Simmelian Multiscale Backbone calculator
+     * @param graph			the input graph
+     * @param alpha			the threshold value for multiscale filtering
+     */
+    SimmelianMultiscaleSparsifier(const Graph &graph, double alpha);
+
+    void run() override;
+
+private:
+    double alpha;
+};
+
+/**
+ * Produces sparsified graphs that contain approximately a given percentage
+ * of edges of the original graph. The edges are selected unformly at random.
+ */
+class RandomSparsifier : public Sparsifier {
+
+public:
+    /**
+     * Creates a new instance of the Random Sparsifier.
+     * @param graph			the input graph
+     * @param ratio			edge ratio in [0,1] to be kept in the sparse graph.
+     */
+    RandomSparsifier(const Graph &graph, double ratio);
+
+    void run() override;
+
+private:
+    double ratio;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_SPARSIFICATION_SPARSIFIERS_HPP_

package/vendor/include/networkit/structures/Cover.hpp

@@ -0,0 +1,248 @@
+/*
+ * Cover.hpp
+ *
+ *  Created on: 03.10.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_STRUCTURES_COVER_HPP_
+#define NETWORKIT_STRUCTURES_COVER_HPP_
+
+#include <iterator>
+#include <map>
+#include <set>
+#include <vector>
+
+#include <networkit/Globals.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup structures
+ * Implements a cover of a set, i.e. an assignment of
+ * its elements to possibly overlapping subsets.
+ */
+class Cover final {
+
+public:
+    /** Default constructor */
+    Cover();
+
+    /**
+     * Create a new cover data structure for elements up to a maximum element index.
+     *
+     * @param[in] z maximum index
+     */
+    Cover(index z);
+
+    /**
+     * Creates a new cover data structure which contains the given partition.
+     *
+     * @param[in] p The partition to construct the cover from
+     */
+    Cover(const Partition &p);
+
+    /**
+     *  Index operator.
+     *
+     *  @param[in] e an element
+     */
+    inline std::set<index> &operator[](const index &e) { return this->data[e]; }
+    /**
+     * Index operator for const instances of this class.
+     *
+     * @param[in] e an element
+     */
+    inline const std::set<index> &operator[](const index &e) const { return this->data[e]; }
+
+    /**
+     * Return the ids of subsets in which the element @a e is contained.
+     *
+     * @param[in] e an element
+     * @return A set of subset ids in which @a e is contained.
+     */
+    inline std::set<index> subsetsOf(index e) const {
+        // TODO: assert (e < this->numberOfElements());
+        return this->data[e];
+    }
+
+    /**
+     * Check if cover assigns a valid subset to the element @a e.
+     *
+     * @param e an element.
+     * @return @c true, if @a e is assigned to a valid subset, @c false otherwise.
+     */
+    bool contains(index e) const;
+
+    /**
+     * Check if two elements @a e1 and @a e2 belong to the same subset.
+     *
+     * @param e1 an element.
+     * @param e2 an element.
+     * @return @c true, if @a e1 and @a e2 belong to the same subset, @c false otherwise.
+     */
+    bool inSameSubset(index e1, index e2) const;
+
+    /**
+     * Get the members of a specific subset @a s.
+     *
+     * @return The set of members of subset @a s.
+     */
+    std::set<index> getMembers(index s) const;
+
+    /**
+     * Add the (previously unassigned) element @a e to the set @a s.
+     * @param[in] s a subset
+     * @param[in] e an element
+     */
+    void addToSubset(index s, index e);
+
+    /**
+     * Remove the element @a e from the set @a s.
+     * @param[in] s a subset
+     * @param[in] e an element
+     */
+    void removeFromSubset(index s, index e);
+
+    /**
+     * Move the element @a e to subset @a s, i.e. remove it from all
+     * other subsets and place it in the subset.
+     *  @param[in] s a subset
+     *  @param[in] e an element
+     */
+    void moveToSubset(index s, index e);
+
+    /**
+     * Creates a singleton set containing the element @a e and returns the index of the new set.
+     * @param[in] e an element
+     * @return The index of the new set.
+     */
+    index toSingleton(index e);
+
+    /**
+     * Assigns every element to a singleton set.
+     * Set id is equal to element id.
+     */
+    void allToSingletons();
+
+    /**
+     * Assigns the elements from both sets to a new set.
+     * @param[in] s a subset
+     * @param[in] t a subset
+     */
+    void mergeSubsets(index s, index t);
+
+    /**
+     * Get an upper bound for the subset ids that have been assigned.
+     * (This is the maximum id + 1.)
+     *
+     * @return An upper bound.
+     */
+    index upperBound() const;
+
+    /**
+     * Get a lower bound for the subset ids that have been assigned.
+     * @return A lower bound.
+     */
+    index lowerBound() const;
+
+    /**
+     * Get a list of subset sizes. Indices do not necessarily correspond to subset ids.
+     *
+     * @return A list of subset sizes.
+     */
+    std::vector<count> subsetSizes() const;
+
+    /**
+     * Get a map from subset id to size of the subset.
+     *
+     * @return A map from subset id to size of the subset.
+     */
+    std::map<index, count> subsetSizeMap() const;
+
+    /**
+     * Get the current number of sets in this cover.
+     *
+     * @return The number of sets in this cover.
+     */
+    count numberOfSubsets() const;
+
+    /**
+     * Get the current number of elements in this cover.
+     *
+     * @return The current number of elements.
+     */
+    count numberOfElements() const;
+
+    /**
+     * Add an additional element (node).
+     */
+    index extend();
+
+    /**
+     * Get the ids of nonempty subsets.
+     *
+     * @return A set of ids of nonempty subsets.
+     */
+    std::set<index> getSubsetIds() const;
+
+    /**
+     * Sets an upper bound for the subset ids that CAN be assigned.
+     *
+     * @param[in] upper highest assigned subset ID + 1
+     */
+    void setUpperBound(index upper);
+
+    /**
+     * Iterate over all entries (node, subset ID of node) and execute callback function @a func
+     * (lambda closure).
+     *
+     * @param func Takes parameters <code>(node, index)</code>
+     */
+    template <typename Callback>
+    void forEntries(Callback func) const;
+
+    /**
+     * Iterate over all entries (node, subset ID of node) in parallel and execute callback function
+     * @a func (lambda closure).
+     *
+     * @param func Takes parameters <code>(node, index)</code>
+     */
+    template <typename Callback>
+    void parallelForEntries(Callback handle) const;
+
+private:
+    index z;     //!< maximum element index that can be mapped
+    index omega; //!< maximum subset index ever assigned
+                 //!< data container, indexed by element id, containing set of subset ids
+    std::vector<std::set<index>> data;
+
+    /**
+     * Allocates and returns a new subset id.
+     */
+    inline index newSubsetId() {
+        omega++;
+        index s = omega;
+        return s;
+    }
+};
+
+template <typename Callback>
+inline void Cover::forEntries(Callback handle) const {
+    for (index e = 0; e <= this->z; e += 1) {
+        handle(e, data[e]);
+    }
+}
+
+template <typename Callback>
+inline void Cover::parallelForEntries(Callback handle) const {
+#pragma omp parallel for
+    for (omp_index e = 0; e <= static_cast<omp_index>(this->z); e += 1) {
+        handle(e, data[e]);
+    }
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_STRUCTURES_COVER_HPP_