@ladybugmem/icebug 0.1.0 → 0.1.2

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

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

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

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