@ladybugmem/icebug 0.1.0 → 0.1.2

package/vendor/include/networkit/linkprediction/JaccardIndex.hpp

@@ -1,44 +0,0 @@
-/*
- * JaccardIndex.hpp
- *
- *  Created on: 23.03.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_JACCARD_INDEX_HPP_
-#define NETWORKIT_LINKPREDICTION_JACCARD_INDEX_HPP_
-
-#include <networkit/linkprediction/LinkPredictor.hpp>
-#include <networkit/linkprediction/NeighborhoodUtility.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Implementation of the Jaccard index which normalizes the Common Neighbors Index.
- * This is done through dividing the number of common neighbors by the number of nodes
- * in the neighboorhood-union.
- */
-class JaccardIndex final : public LinkPredictor {
-    /**
-     * Returns the Jaccard index for the given node-pair (@a u, @a v).
-     * @param u First node
-     * @param v Second node
-     * @return the Jaccard index for the given node-pair (@a u, @a v)
-     */
-    double runImpl(node u, node v) override {
-        const auto unionSize = NeighborhoodUtility::getNeighborsUnion(*G, u, v).size();
-        if (unionSize == 0) {
-            return 0;
-        }
-        return 1.0 * NeighborhoodUtility::getCommonNeighbors(*G, u, v).size() / unionSize;
-    }
-
-public:
-    using LinkPredictor::LinkPredictor;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_JACCARD_INDEX_HPP_

package/vendor/include/networkit/linkprediction/KatzIndex.hpp

@@ -1,84 +0,0 @@
-/*
- * KatzIndex.hpp
- *
- *  Created on: 30.01.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_KATZ_INDEX_HPP_
-#define NETWORKIT_LINKPREDICTION_KATZ_INDEX_HPP_
-
-#include <unordered_map>
-
-#include <networkit/linkprediction/LinkPredictor.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Implementation of the Katz index.
- * Katz index assigns a pair of nodes a similarity score
- * that is based on the sum of the weighted number of paths of length l
- * where l is smaller than a given limit.
- */
-class KatzIndex final : public LinkPredictor {
-    count maxPathLength; //!< Maximal length of the paths to consider
-
-    double dampingValue; //!< Damping factor in (0,1) used to exponentially damp every addend of the
-                         //!< sum
-
-    node lastStartNode; //!< Node at which the algorithm started at the last call
-
-    std::unordered_map<node, double>
-        lastScores; //!< Stores the last generated scores from the lastStartNode
-
-    std::vector<double>
-        dampingFactors; //!< Stores precalculated damping factors to increase performance
-
-    // Helper method used to access the score for a given node-pair. Checks which of the given nodes
-    // was used as the starting node and uses the other node to access the last scores generated.
-    // Defaults to 0.0 if no score could be found.
-    double getScore(node u, node v) const;
-
-    /**
-     * Returns the similarity score for the given node-pair based on the Katz index specified during
-     * construction. The algorithm considers all paths starting at the node with the smaller degree
-     * except the algorithm started at the other node at the last call.
-     * @param u First node
-     * @param v Second node
-     * @return the similarity score of the given node-pair calculated by the specified Katz index
-     */
-    double runImpl(node u, node v) override;
-
-    /**
-     * Calculated the damping factors for every path length smaller or equal to maxPathLength.
-     * This can be used to cache damping factors to increase performance through reuse.
-     * The results will be stored in dampingFactors and dampingFactors[0] is always 1.
-     */
-    void calcDampingFactors();
-
-public:
-    /**
-     * @param maxPathLength Maximal length of the paths to consider
-     * @param dampingValue Used to exponentially damp every addend of the sum. Should be in (0, 1]
-     */
-    explicit KatzIndex(count maxPathLength = 5, double dampingValue = 0.005);
-
-    /**
-     * @param G The graph to operate on
-     * @param maxPathLength Maximal length of the paths to consider
-     * @param dampingValue Used to exponentially damp every addend of the sum. Should be in (0, 1]
-     */
-    explicit KatzIndex(const Graph &G, count maxPathLength = 5, double dampingValue = 0.005);
-
-    // Overriding this method is necessary as the implementation of the Katz index makes use
-    // of caching. This makes run() not thread-safe. To still achieve performance gains
-    // we split the nodePairs into subsets and create a new Katz instance for every subset.
-    std::vector<LinkPredictor::prediction>
-    runOn(std::vector<std::pair<node, node>> nodePairs) override;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_KATZ_INDEX_HPP_

package/vendor/include/networkit/linkprediction/LinkPredictor.hpp

@@ -1,98 +0,0 @@
-/*
- * LinkPredictor.hpp
- *
- *  Created on: 28.02.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_LINK_PREDICTOR_HPP_
-#define NETWORKIT_LINKPREDICTION_LINK_PREDICTOR_HPP_
-
-#include <memory>
-
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Abstract base class for link predictors.
- */
-class LinkPredictor {
-public:
-    // Declare typedef in advance for use in the protected section
-    using prediction = std::pair<std::pair<node, node>, double>; //!< Type of predictions
-
-private:
-    /**
-     * Subclasses implement this private method to inject the custom predictor-code.
-     * Subclasses don't have to check whether the arguments are valid or a graph is set.
-     * @param u First node in graph
-     * @param v Second node in graph
-     * @return a prediction-score indicating the likelihood of a future link between the given nodes
-     */
-    virtual double runImpl(node u, node v) = 0;
-
-protected:
-    const Graph *G; //!< Graph to operate on
-
-    bool validCache; //!< Indicates whether a possibly used cache is valid
-
-public:
-    LinkPredictor();
-
-    /**
-     *
-     * @param G The graph to work on
-     */
-    explicit LinkPredictor(const Graph &G);
-
-    /**
-     * Default destructor.
-     */
-    virtual ~LinkPredictor() = default;
-
-    /**
-     * Sets the graph to work on.
-     * @param newGraph The graph to work on
-     */
-    virtual void setGraph(const Graph &newGraph);
-
-    /**
-     * Returns a score indicating the likelihood of a future link between the given nodes.
-     * Prior to calling this method a graph should be provided through the constructor or
-     * by calling setGraph. Note that only undirected graphs are accepted.
-     * There is also no lower or upper bound for scores and the actual range of values depends
-     * on the specific link predictor implementation. In case @a u == @a v a 0 is returned.
-     * If suitable this method might make use of parallelization to enhance performance.
-     * @param u First node in graph
-     * @param v Second node in graph
-     * @return a prediction-score indicating the likelihood of a future link between the given nodes
-     */
-    virtual double run(node u, node v);
-
-    /**
-     * Executes the run-method on al given @a nodePairs and returns a vector of predictions.
-     * The result is a vector of pairs where the first element is the node-pair and it's second
-     * element the corresponding score generated by the run-method. The method makes use of
-     * parallelization.
-     * @param nodePairs Node-pairs to run the predictor on
-     * @return a vector of pairs containing the given node-pair as the first element and it's
-     * corresponding score as the second element. The vector is sorted ascendingly by node-pair
-     */
-    virtual std::vector<prediction> runOn(std::vector<std::pair<node, node>> nodePairs);
-
-    /**
-     * Runs the link predictor on all currently unconnected node-pairs.
-     * Possible self-loops are also excluded. The method makes use of parallelization.
-     * @return a vector of pairs containing all currently unconnected node-pairs as the first
-     * elements and the corresponding scores as the second elements. The vector is sorted
-     * ascendingly by node-pair
-     */
-    virtual std::vector<prediction> runAll();
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_LINK_PREDICTOR_HPP_

package/vendor/include/networkit/linkprediction/LinkThresholder.hpp

@@ -1,56 +0,0 @@
-/*
- * LinkThresholder.hpp
- *
- *  Created on: 01.04.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_LINK_THRESHOLDER_HPP_
-#define NETWORKIT_LINKPREDICTION_LINK_THRESHOLDER_HPP_
-
-#include <networkit/linkprediction/LinkPredictor.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Filters given predictions based on some criterion and returns a vector of
- * node-pairs that fulfill the given criterion.
- * This can be used to determine which node-pairs should actually be interpreted
- * as future links and which shouldn't.
- */
-namespace LinkThresholder {
-
-/**
- * Returns the node-pairs whose scores are at least equal to the given @a minScore.
- * @param predictions Predictions to filter
- * @param minScore Minimal score that the returned node-pairs should have
- * @return a vector of node-pairs whose scores are at least equal to the given @a minScore
- */
-std::vector<std::pair<node, node>>
-byScore(const std::vector<LinkPredictor::prediction> &predictions, double minScore);
-
-/**
- * Returns the first @a numLinks highest scored node-pairs.
- * @param predictions Predictions to filter
- * @param numLinks Number of top-scored node-pairs to return
- * @return the first @a numLinks highest scored node-pairs
- */
-std::vector<std::pair<node, node>>
-byCount(const std::vector<LinkPredictor::prediction> &predictions, count numLinks);
-
-/**
- * Returns the first @a percentageLinks percent of the highest scores node-pairs.
- * @param predictions Predictions to filter
- * @param percentageLinks Percentage of highest scored node-pairs to return
- * @return the first @a percentageLinks percent of the highest scores node-pairs
- */
-std::vector<std::pair<node, node>>
-byPercentage(const std::vector<LinkPredictor::prediction> &predictions, double percentageLinks);
-
-} // namespace LinkThresholder
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_LINK_THRESHOLDER_HPP_

package/vendor/include/networkit/linkprediction/MissingLinksFinder.hpp

@@ -1,60 +0,0 @@
-/*
- * MissingLinksFinder.hpp
- *
- *  Created on: 20.03.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_MISSING_LINKS_FINDER_HPP_
-#define NETWORKIT_LINKPREDICTION_MISSING_LINKS_FINDER_HPP_
-
-#include <utility>
-
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Allows the user to find missing links in the given graph.
- * The absent links to find are narrowed down by providing a distance
- * that the nodes of the missing links should have.
- * For example in case of distance 2 only node-pairs that would close
- * a triangle in the given graph get returned.
- */
-class MissingLinksFinder final {
-    const Graph *G; //!< The graph to find missing links in
-
-public:
-    /**
-     *
-     * @param G The graph to find missing links in
-     */
-    explicit MissingLinksFinder(const Graph &G);
-
-    /**
-     * Returns all missing links in the graph that have distance @a k.
-     * Note that a distance of @a k actually means that there are @a k different links
-     * on the path of the two nodes that are connected through that path.
-     * @param k Distance of the absent links
-     * @return an ascendingly sorted vector of node-pairs where there is a missing link of distance
-     * @a k between the two nodes
-     */
-    std::vector<std::pair<node, node>> findAtDistance(count k);
-
-    /**
-     * Returns all missing links in the graph that have distance @a k and are connected to @a u.
-     * Note that a distance of @a k actually means that there are @a k different links
-     * on the path of the two nodes that are connected through that path.
-     * @param u Node to find missing links from
-     * @param k Distance of the absent links
-     * @return a vector of node-pairs where there is a missing link of distance @a k
-     * between the given node @a u and another node in the graph
-     */
-    std::vector<std::pair<node, node>> findFromNode(node u, count k);
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_MISSING_LINKS_FINDER_HPP_

package/vendor/include/networkit/linkprediction/NeighborhoodDistanceIndex.hpp

@@ -1,42 +0,0 @@
-/*
- * NeighborhoodDistanceIndex.hpp
- *
- *  Created on: 24.06.2013
- *      Authors: cls, Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_NEIGHBORHOOD_DISTANCE_INDEX_HPP_
-#define NETWORKIT_LINKPREDICTION_NEIGHBORHOOD_DISTANCE_INDEX_HPP_
-
-#include <cmath>
-
-#include <networkit/linkprediction/LinkPredictor.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Assigns a distance value to pairs of nodes according to the
- * overlap of their neighborhoods.
- */
-class NeighborhoodDistanceIndex final : public LinkPredictor {
-    /**
-     * Returns the Neighborhood Distance index for the given node-pair (@a u, @a v).
-     * @param u First node
-     * @param v Second node
-     * @return the Neighborhood Distance index for the given node-pair (@a u, @a v)
-     */
-    double runImpl(node u, node v) override {
-        count uNeighborhood = G->degree(u);
-        count vNeighborhood = G->degree(v);
-        count intersection = NeighborhoodUtility::getCommonNeighbors(*G, u, v).size();
-        return ((double)intersection) / (std::sqrt(uNeighborhood * vNeighborhood));
-    }
-
-public:
-    using LinkPredictor::LinkPredictor;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_LINKPREDICTION_NEIGHBORHOOD_DISTANCE_INDEX_HPP_

package/vendor/include/networkit/linkprediction/NeighborhoodUtility.hpp

@@ -1,54 +0,0 @@
-/*
- * NeighborhoodUtility.hpp
- *
- *  Created on: 06.04.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_NEIGHBORHOOD_UTILITY_HPP_
-#define NETWORKIT_LINKPREDICTION_NEIGHBORHOOD_UTILITY_HPP_
-
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Provides basic operations on neighborhoods in a given graph.
- */
-class NeighborhoodUtility final {
-    /**
-     * Sorts and returns the neighborhoods of the nodes @a u and @a v in the given graph @a G.
-     * @param G Graph to obtain neighborhoods from
-     * @param u First node in the graph
-     * @param v Second node in the graph
-     * @return the sorted nodes regarding the neighborhoods of the nodes @a u and @a v in the given
-     * graph @a G.
-     */
-    static std::pair<std::vector<node>, std::vector<node>> getSortedNeighborhoods(const Graph &G,
-                                                                                  node u, node v);
-
-public:
-    /**
-     * Returns the union of the neighboorhoods of @a u and @a v.
-     * @param G Graph to obtain neighbors-union from
-     * @param u First node
-     * @param v Second node
-     * @return a vector containing all the nodes in the neighborhood-union of @a u and @a v
-     */
-    static std::vector<node> getNeighborsUnion(const Graph &G, node u, node v);
-
-    /**
-     * Returns a vector containing the node-ids of all common neighbors of @a u and @a v.
-     * @param G Graph to obtain common neighbors from
-     * @param u First node
-     * @param v Second node
-     * @return a vector containing the node-ids of all common neighbors of @a u and @a v
-     */
-    static std::vector<node> getCommonNeighbors(const Graph &G, node u, node v);
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_NEIGHBORHOOD_UTILITY_HPP_

package/vendor/include/networkit/linkprediction/NeighborsMeasureIndex.hpp

@@ -1,48 +0,0 @@
-/*
- * NeighborsMeasureIndex.hpp
- *
- *  Created on: 05.04.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_NEIGHBORS_MEASURE_INDEX_HPP_
-#define NETWORKIT_LINKPREDICTION_NEIGHBORS_MEASURE_INDEX_HPP_
-
-#include <networkit/linkprediction/LinkPredictor.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Implementation of the Neighbors Measure Index.
- * This index is also known as Friends Measure and simply returns
- * the number of connections between neighbors of the given nodes u and v.
- */
-class NeighborsMeasureIndex final : public LinkPredictor {
-    /**
-     * Returns the number of connections between neighbors of @a u and @a v.
-     * @param u First node
-     * @param v Second node
-     * @return the number of connections between neighbors of @a u and @a v
-     */
-    double runImpl(node u, node v) override {
-        double neighborConnections = 0;
-        G->forNeighborsOf(u, [&](node uNeighbor) {
-            G->forNeighborsOf(v, [&](node vNeighbor) {
-                // Don't count self-loops
-                if (uNeighbor == vNeighbor || G->hasEdge(uNeighbor, vNeighbor)) {
-                    ++neighborConnections;
-                }
-            });
-        });
-        return neighborConnections;
-    }
-
-public:
-    using LinkPredictor::LinkPredictor;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_NEIGHBORS_MEASURE_INDEX_HPP_

package/vendor/include/networkit/linkprediction/PrecisionRecallMetric.hpp

@@ -1,40 +0,0 @@
-/*
- * PrecisionRecallMetric.hpp
- *
- *  Created on: 21.03.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_PRECISION_RECALL_METRIC_HPP_
-#define NETWORKIT_LINKPREDICTION_PRECISION_RECALL_METRIC_HPP_
-
-#include <networkit/graph/Graph.hpp>
-#include <networkit/linkprediction/EvaluationMetric.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Provides points that define the Precision-Recall curve for a given set of predictions.
- * Based on the generated points the area under the curve can be calculated with the trapzoidal
- * rule.
- */
-class PrecisionRecallMetric final : public EvaluationMetric {
-    /**
-     * Generates the points for the Precision-Recall curve with respect to the given predictions.
-     * The curve assigns every recall-value a corresponding precision as the y-value.
-     * In case of a tie regarding multiple y-values for a x-value the smallest (= latest) y-value
-     * will be used.
-     * @return a pair of vectors where the first vector contains all recall-values and the second
-     * vector the corresponding precision-values
-     */
-    std::pair<std::vector<double>, std::vector<double>> generatePoints() override;
-
-public:
-    using EvaluationMetric::EvaluationMetric;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_PRECISION_RECALL_METRIC_HPP_

package/vendor/include/networkit/linkprediction/PredictionsSorter.hpp

@@ -1,66 +0,0 @@
-/*
- * PredictionsSorter.hpp
- *
- *  Created on: 26.04.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_PREDICTIONS_SORTER_HPP_
-#define NETWORKIT_LINKPREDICTION_PREDICTIONS_SORTER_HPP_
-
-#include <networkit/linkprediction/LinkPredictor.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Allows the sorting of predictions by score or node-pair.
- */
-class PredictionsSorter final {
-    /**
-     * Comparator used to sort predictions descendingly by score and on equality
-     * ascendingly by node-pairs which means e.g. (0, 1) < (1, 1) and (0, 0) < (0, 1).
-     */
-    struct ScoreComp {
-        bool operator()(const LinkPredictor::prediction &a,
-                        const LinkPredictor::prediction &b) const {
-            return (a.second > b.second) || (a.second == b.second && a.first < b.first);
-        }
-    };
-
-    static ScoreComp ConcreteScoreComp; //!< Comparator instance for score-based comparison
-
-    /**
-     * Comparator used to sort predictions ascendingly by node-pairs.
-     */
-    struct NodePairComp {
-        bool operator()(const LinkPredictor::prediction &a,
-                        const LinkPredictor::prediction &b) const {
-            return a.first < b.first;
-        }
-    };
-
-    static NodePairComp
-        ConcreteNodePairComp; //!< Comparator instance for node-pair-based comparison
-
-public:
-    /**
-     * Sorts the @a predictions descendingly by score.
-     * In case there is a tie the node-pairs are used as a tie-breaker by sorting them
-     * ascendingly on the first node and on a tie ascendingly by the second node.
-     * @param predictions The predictions to sort
-     */
-    static void sortByScore(std::vector<LinkPredictor::prediction> &predictions);
-
-    /**
-     * Sorts the @a predictions ascendingly by node-pair.
-     * This means for example (0, 0) < (0, 1) and (1, 1) < (1, 0).
-     * @param predictions The predictions to sort
-     */
-    static void sortByNodePair(std::vector<LinkPredictor::prediction> &predictions);
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_PREDICTIONS_SORTER_HPP_

package/vendor/include/networkit/linkprediction/PreferentialAttachmentIndex.hpp

@@ -1,37 +0,0 @@
-/*
- * PreferentialAttachmentIndex.hpp
- *
- *  Created on: 22.03.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_PREFERENTIAL_ATTACHMENT_INDEX_HPP_
-#define NETWORKIT_LINKPREDICTION_PREFERENTIAL_ATTACHMENT_INDEX_HPP_
-
-#include <networkit/linkprediction/LinkPredictor.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Implementation of the Preferential Attachment Index.
- * The run-method simply calculates the product of the number of nodes in the neighborhoods
- * regarding the given nodes.
- */
-class PreferentialAttachmentIndex final : public LinkPredictor {
-    /**
-     * Returns the product of the cardinalities of the neighborhoods regarding @a u and @a v.
-     * @param u First node
-     * @param v Second node
-     * @return the product of the cardinalities of the neighborhoods regarding @a u and @a v
-     */
-    double runImpl(node u, node v) override { return G->degree(u) * G->degree(v); }
-
-public:
-    using LinkPredictor::LinkPredictor;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_PREFERENTIAL_ATTACHMENT_INDEX_HPP_

package/vendor/include/networkit/linkprediction/ROCMetric.hpp

@@ -1,39 +0,0 @@
-/*
- * ROCMetric.hpp
- *
- *  Created on: 14.03.2015
- *      Author: Kolja Esders
- */
-
-#ifndef NETWORKIT_LINKPREDICTION_ROC_METRIC_HPP_
-#define NETWORKIT_LINKPREDICTION_ROC_METRIC_HPP_
-
-#include <networkit/graph/Graph.hpp>
-#include <networkit/linkprediction/EvaluationMetric.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup linkprediction
- *
- * Provides points that define the Receiver Operating Characteristic curve for a given set of
- * predictions. Based on the generated points the area under the curve can be calculated with the
- * trapzoidal rule.
- */
-class ROCMetric final : public EvaluationMetric {
-    /**
-     * Generate the points of the Receiver Operating Characteristic curve regarding the previously
-     * set predictions. Note that in the case of multiple y-values mapping to the same x-value the
-     * highest (=latest) y-value gets picked.
-     * @return a pair of vectors where the first vector contains the false positive rates and the
-     * second vector the corresponding true positive rates
-     */
-    std::pair<std::vector<double>, std::vector<double>> generatePoints() override;
-
-public:
-    using EvaluationMetric::EvaluationMetric;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_LINKPREDICTION_ROC_METRIC_HPP_