@ladybugmem/icebug 0.1.0

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

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

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

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

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

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

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

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

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

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

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

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

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