@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/io/RBMatrixReader.hpp

@@ -0,0 +1,49 @@
+/*
+ * RBMatrixReader.hpp
+ *
+ *  Created on: 16.10.2024
+ *      Author: bernlu
+ */
+
+#ifndef NETWORKIT_IO_RB_MATRIX_READER_HPP_
+#define NETWORKIT_IO_RB_MATRIX_READER_HPP_
+
+#include <networkit/io/MatrixReader.hpp>
+#include <networkit/io/RBGraphReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Reader for the Rutherford Boeing (RB) matrix file format as described in
+ * http://sparse-files.engr.tamu.edu/files/DOC/rb.pdf.
+ *
+ * @note currently the reader only supports compressed column format for real, integer, or pattern
+ * data types.
+ */
+class RBMatrixReader final : public MatrixReader {
+public:
+    RBMatrixReader() = default;
+
+    CSRMatrix read(std::string_view path) override;
+
+    /** Reads the matrix in @a in. */
+    CSRMatrix read(std::istream &in);
+
+private:
+    friend RBGraphReader;
+    // data format is CSC
+    std::vector<index> pointers;
+    std::vector<index> rowindex;
+    std::vector<double> values;
+
+    count nMatrixRows;
+    count nMatrixCols;
+    count nMatrixVals;
+    bool symmetric = false;
+    bool patternOnly = false;
+    void readToVectors(std::istream &in);
+};
+
+} // namespace NetworKit
+#endif // NETWORKIT_IO_RB_MATRIX_READER_HPP_

package/vendor/include/networkit/io/RasterReader.hpp

@@ -0,0 +1,40 @@
+/*
+ * RasterReader.hpp
+ *
+ *  Created on: 20.07.2015
+ *      Author: Henning
+ */
+
+#ifndef NETWORKIT_IO_RASTER_READER_HPP_
+#define NETWORKIT_IO_RASTER_READER_HPP_
+
+#include <string>
+#include <vector>
+
+namespace NetworKit {
+
+/**
+ * Reader for NASA raster data of population.
+ * Coordinate transformation into the unit square takes place.
+ * Within each grid cell, points get a random location.
+ */
+class RasterReader final {
+    double normalizationFactor;
+
+public:
+    /**
+     * @param[in] Factor by which population per grid cell should be multiplied
+     */
+    RasterReader(double normalizationFactor);
+
+    ~RasterReader() = default;
+
+    /**
+     * @param[in] path Path and name of file to be read.
+     * @return Vectors of x- and y-coordinates of the points.
+     */
+    std::pair<std::vector<double>, std::vector<double>> read(std::string_view path);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_RASTER_READER_HPP_

package/vendor/include/networkit/io/SNAPEdgeListPartitionReader.hpp

@@ -0,0 +1,28 @@
+/*
+ * SNAPEdgeListPartitionReader.hpp
+ *
+ *  Created on: Jun 20, 2013
+ *      Author: forigem
+ */
+
+#ifndef NETWORKIT_IO_SNAP_EDGE_LIST_PARTITION_READER_HPP_
+#define NETWORKIT_IO_SNAP_EDGE_LIST_PARTITION_READER_HPP_
+
+#include <unordered_map>
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Cover.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Reads the clustering files from the SNAP collection.
+ */
+class SNAPEdgeListPartitionReader final {
+public:
+    Cover read(std::string_view path, std::unordered_map<node, node> &mapNodeIds, Graph &G);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_SNAP_EDGE_LIST_PARTITION_READER_HPP_

package/vendor/include/networkit/io/SNAPGraphReader.hpp

@@ -0,0 +1,53 @@
+/*
+ * SNAPGraphReader.hpp
+ *
+ *  Created on: 04.05.2018
+ *      Author: Alexander van der Grinten
+ */
+
+#ifndef NETWORKIT_IO_SNAP_GRAPH_READER_HPP_
+#define NETWORKIT_IO_SNAP_GRAPH_READER_HPP_
+
+#include <unordered_map>
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/io/GraphReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class SNAPGraphReader final : public GraphReader {
+    std::unordered_map<node, node> nodeIdMap;
+    bool directed;
+    count nodeCount;
+    bool remapNodes;
+
+public:
+    /**
+     * Default constructor for the SNAPGraphReader.
+     * NOTE: Keep in mind that many SNAP graphs do not have consecutive node ids.
+     * Passing a "false" in remapNodes forces the reader to add nodes for the highest occuring node
+     * id. This may result in a lot of isolated nodes, but further increases the speed of x2(in
+     * benchmarking)
+     *
+     * @param[in]  directed  reads in the graph as directed, if set to true
+     * @param[in]  remapNodes  indicates whether nodes should be remapped to other node ids in order
+     * to create consecutive node ids
+     * @param[in]  nodeCount  nodeCount is used to preallocated memory for the number of nodes
+     */
+    SNAPGraphReader(bool directed = false, const bool &remapNodes = true,
+                    const count &nodeCount = 0);
+
+    /**
+     * Given the path of an input file, read the graph contained.
+     *
+     * @param[in]  path  input file path
+     */
+    GraphW read(std::string_view path) override;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_IO_SNAP_GRAPH_READER_HPP_

package/vendor/include/networkit/io/SNAPGraphWriter.hpp

@@ -0,0 +1,53 @@
+/*
+ * SNAPGraphWriter.hpp
+ *
+ *  Created on: 24.09.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_IO_SNAP_GRAPH_WRITER_HPP_
+#define NETWORKIT_IO_SNAP_GRAPH_WRITER_HPP_
+
+#include <networkit/io/GraphWriter.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Write graph in the Georgia Tech SNAP (Small-world Network
+ * Analysis and Partitioning) (http://snap-graph.sourceforge.net/)
+ * file format (do not confuse this with the Stanford Network Analysis Project.)
+ * From the SNAP user guide:
+ *
+ * A sample graph file in the SNAP format (.gr extension)
+ * (lines beginning with a # symbol indicate comments)
+ *
+ * p denotes the problem line
+ * p <n> <m> <undirected/directed> <weight_type> <0 or 1-indexed>
+ *
+ * n indicates the number of vertices.
+ *
+ * m denotes the number of edges.
+ *
+ * The third parameter can be either u denoting a undirected graph,
+ * or d denoting a directed graph. Internally, an edge <u, v> in an
+ * undirected graph is stored as two directed links u->v and v->u.
+ *
+ * weight_type can be u (unweighted), i (integer), l (long, 8 bytes on 64-bit
+ * architectures), f (float), or d (double)
+ *
+ * For the fifth parameter, 0 indicates that the valid range of vertex IDs
+ * is 0 to n-1. 1 indicates that it is 1 to n.
+ *
+ * The problem line is followed by a listing on exactly m edges. The format
+ * is <u v w> for a weighted graph, and <u v> for an unweighted graph.
+ */
+class SNAPGraphWriter final : public GraphWriter {
+public:
+    SNAPGraphWriter() = default;
+
+    void write(const Graph &G, std::string_view path) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_SNAP_GRAPH_WRITER_HPP_

package/vendor/include/networkit/io/ThrillGraphBinaryReader.hpp

@@ -0,0 +1,44 @@
+/*
+ * ThrillGraphBinaryReader.hpp
+ *
+ * @author Michael Hamann
+ */
+
+#ifndef NETWORKIT_IO_THRILL_GRAPH_BINARY_READER_HPP_
+#define NETWORKIT_IO_THRILL_GRAPH_BINARY_READER_HPP_
+
+#include <string>
+#include <vector>
+
+#include <networkit/io/GraphReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * Reads a graph format consisting of a serialized DIA of vector<uint32_t> from thrill.
+ */
+class ThrillGraphBinaryReader final : public GraphReader {
+
+public:
+    /**
+     * When the number of nodes is given, reading the graph is more efficient.
+     *
+     * @param[in]  n  The number of nodes
+     */
+    ThrillGraphBinaryReader(count n = 0);
+
+    /**
+     * Given the path of an input file, read the graph contained.
+     *
+     * @param[in]  path  input file path
+     */
+    GraphW read(std::string_view path) override;
+
+    GraphW read(const std::vector<std::string> &path);
+
+private:
+    const count n;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_THRILL_GRAPH_BINARY_READER_HPP_

package/vendor/include/networkit/io/ThrillGraphBinaryWriter.hpp

@@ -0,0 +1,27 @@
+/*
+ * ThrillGraphBinaryWriter.hpp
+ *
+ * @author Michael Hamann
+ */
+
+#ifndef NETWORKIT_IO_THRILL_GRAPH_BINARY_WRITER_HPP_
+#define NETWORKIT_IO_THRILL_GRAPH_BINARY_WRITER_HPP_
+
+#include <networkit/io/GraphWriter.hpp>
+
+namespace NetworKit {
+
+class ThrillGraphBinaryWriter final : public GraphWriter {
+public:
+    /**
+     * Write the given graph into a binary file at the given path.
+     *
+     * @param[in] G The graph to write.
+     * @param[in] path The path where to write the graph.
+     */
+    void write(const Graph &G, std::string_view path) override;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_IO_THRILL_GRAPH_BINARY_WRITER_HPP_

package/vendor/include/networkit/layout/LayoutAlgorithm.hpp

@@ -0,0 +1,39 @@
+/*
+ * LayoutAlgorithm.hpp
+ *
+ *  Created on: May 20 2015
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_LAYOUT_LAYOUT_ALGORITHM_HPP_
+#define NETWORKIT_LAYOUT_LAYOUT_ALGORITHM_HPP_
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup layout
+ *
+ * Base class for graph layout algorithms, i.e. algorithms that compute
+ * a layout in form of 2D coordinates for nodes.
+ */
+class LayoutAlgorithm {
+
+public:
+    LayoutAlgorithm(const Graph &G)
+        : G(G){
+
+        };
+
+    virtual void run() = 0;
+
+    virtual std::vector<std::pair<double, double>> getLayout() { return layout; };
+
+protected:
+    const Graph *G;
+    std::vector<std::pair<double, double>> layout;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_LAYOUT_LAYOUT_ALGORITHM_HPP_

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

@@ -0,0 +1,37 @@
+/*
+ * AdamicAdarIndex.hpp
+ *
+ *  Created on: 25.03.2015
+ *      Author: Kolja Esders
+ */
+
+#ifndef NETWORKIT_LINKPREDICTION_ADAMIC_ADAR_INDEX_HPP_
+#define NETWORKIT_LINKPREDICTION_ADAMIC_ADAR_INDEX_HPP_
+
+#include <networkit/linkprediction/LinkPredictor.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup linkprediction
+ *
+ * Implementation of the Adamic/Adar Index.
+ * The index sums up the reciprocals of the logarithm of the degree of all
+ * common neighbors of u and v.
+ */
+class AdamicAdarIndex final : public LinkPredictor {
+    /**
+     * Returns the Adamic/Adar Index of the given node-pair (@a u, @a v).
+     * @param u First node
+     * @param v Second node
+     * @return the Adamic/Adar Index of the given node-pair (@a u, @a v)
+     */
+    double runImpl(node u, node v) override;
+
+public:
+    using LinkPredictor::LinkPredictor;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_LINKPREDICTION_ADAMIC_ADAR_INDEX_HPP_

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

@@ -0,0 +1,36 @@
+/*
+ * AdjustedRandIndex.hpp
+ *
+ *  Created on: 11.04.2015
+ *      Author: Kolja Esders
+ */
+
+#ifndef NETWORKIT_LINKPREDICTION_ADJUSTED_RAND_INDEX_HPP_
+#define NETWORKIT_LINKPREDICTION_ADJUSTED_RAND_INDEX_HPP_
+
+#include <networkit/linkprediction/LinkPredictor.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup linkprediction
+ *
+ * AdjustedRandIndex proposed by Hoffman et al. with natural threshold of 0.
+ * See http://www.sciencedirect.com/science/article/pii/S0378873315000210 for details.
+ */
+class AdjustedRandIndex final : public LinkPredictor {
+    /**
+     * Returns the Adjusted Rand Index of the given node-pair (@a u, @a v).
+     * @param u First node
+     * @param v Second node
+     * @return the Adjusted Rand Index of the given node-pair (@a u, @a v)
+     */
+    double runImpl(node u, node v) override;
+
+public:
+    using LinkPredictor::LinkPredictor;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_LINKPREDICTION_ADJUSTED_RAND_INDEX_HPP_

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

@@ -0,0 +1,70 @@
+/*
+ * AlgebraicDistanceIndex.hpp
+ *
+ *  Created on: 19.06.2013
+ *      Authors: cls, Kolja Esders
+ */
+
+#ifndef NETWORKIT_LINKPREDICTION_ALGEBRAIC_DISTANCE_INDEX_HPP_
+#define NETWORKIT_LINKPREDICTION_ALGEBRAIC_DISTANCE_INDEX_HPP_
+
+#include <networkit/auxiliary/Timer.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/linkprediction/LinkPredictor.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup linkprediction
+ *
+ * Algebraic distance assigns a distance value to pairs of nodes
+ * according to their structural closeness in the graph.
+ */
+class AlgebraicDistanceIndex final : public LinkPredictor {
+    /**
+     * Returns the extended algebraic distance between node @a u and node @a v in the norm specified
+     * in the constructor.
+     * @param u The first node
+     * @param v The second node
+     * @return Extended algebraic distance between the two nodes.
+     */
+    double runImpl(node u, node v) override;
+
+    count numSystems; //!< number of vectors/systems used for algebraic iteration
+    count numIters;   //!< number of iterations in each system
+    double omega;
+    index norm;
+    static constexpr index MAX_NORM{0};
+
+    std::vector<std::vector<double>>
+        loads; //!< loads[i]: vector of loads of length n for one system
+
+    void randomInit();
+
+public:
+    explicit AlgebraicDistanceIndex(count numberSystems, count numberIterations, double omega = 0.5,
+                                    index norm = 2);
+
+    /**
+     * @param G The graph.
+     * @param numberSystems Number of vectors/systems used for algebraic iteration.
+     * @param numberIterations Number of iterations in each system.
+     * @param omega Overrelaxation parameter.
+     * @param norm The norm factor of the extended algebraic distance. Maximum norm is realized by
+     * setting @a norm to 0.
+     */
+    explicit AlgebraicDistanceIndex(const Graph &G, count numberSystems, count numberIterations,
+                                    double omega = 0.5, index norm = 2);
+
+    /**
+     * Starting with random initialization, compute for all @a numberSystems
+     * "diffusion" systems the situation after @a numberIterations iterations
+     * of overrelaxation with overrelaxation parameter @a omega.
+     *
+     * REQ: Needs to be called before algdist delivers meaningful results!
+     */
+    void preprocess();
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_LINKPREDICTION_ALGEBRAIC_DISTANCE_INDEX_HPP_

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

@@ -0,0 +1,39 @@
+/*
+ * CommonNeighborsIndex.hpp
+ *
+ *  Created on: 06.12.2014
+ *      Author: Kolja Esders
+ */
+
+#ifndef NETWORKIT_LINKPREDICTION_COMMON_NEIGHBORS_INDEX_HPP_
+#define NETWORKIT_LINKPREDICTION_COMMON_NEIGHBORS_INDEX_HPP_
+
+#include <networkit/linkprediction/LinkPredictor.hpp>
+#include <networkit/linkprediction/NeighborhoodUtility.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup linkprediction
+ *
+ * The CommonNeighborsIndex calculates the number of common
+ * neighbors of a node-pair in a given graph.
+ */
+class CommonNeighborsIndex final : public LinkPredictor {
+    /**
+     * Returns the number of common neighbors of the given nodes @a u and @a v.
+     * @param u First node
+     * @param v Second node
+     * @return the number of common neighbors of @a u and @a v
+     */
+    double runImpl(node u, node v) override {
+        return NeighborhoodUtility::getCommonNeighbors(*G, u, v).size();
+    }
+
+public:
+    using LinkPredictor::LinkPredictor;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_LINKPREDICTION_COMMON_NEIGHBORS_INDEX_HPP_

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

@@ -0,0 +1,135 @@
+/*
+ * EvaluationMetric.hpp
+ *
+ *  Created on: 17.03.2015
+ *      Author: Kolja Esders
+ */
+
+#ifndef NETWORKIT_LINKPREDICTION_EVALUATION_METRIC_HPP_
+#define NETWORKIT_LINKPREDICTION_EVALUATION_METRIC_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/linkprediction/LinkPredictor.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup linkprediction
+ *
+ * Abstract base class for evaluation curves.
+ * The evaluation curves are generated based on the predictions calculated
+ * by the link predictor and a testGraph to compare against.
+ */
+class EvaluationMetric {
+    /**
+     * Generates the points on the evaluation curve. Each metric will implement
+     * it's own way to generate those points.
+     * Doesn't have to check if testGraph or predictions are existent.
+     * @return a pair of X- and Y-vectors (in that order) that can be used for plotting
+     */
+    virtual std::pair<std::vector<double>, std::vector<double>> generatePoints() = 0;
+
+    /**
+     * Helper function that bundles the calculation of all statistical measures including
+     * number of TP, FP, TN, FN and also absolute number of positives and negatives.
+     */
+    void calculateStatisticalMeasures();
+
+    // The following three helper methods generate statistical measures for every threshold
+    // based on the given predictions. The names should be self-explanatory.
+    void setPositivesAndNegatives();
+
+    void setTrueAndFalsePositives();
+
+    void setTrueAndFalseNegatives();
+
+    /**
+     * Sorts the given pair of vectors ascendingly with respect to the values of the first vector.
+     * This effectively leads to an sorted pair of vectors where each x-value still maps to the
+     * same y-value but the x-values are sorted ascendingly from 0 to 1.
+     * @param curve Points to sort
+     */
+    void sortPointsOfCurve(std::pair<std::vector<double>, std::vector<double>> &curve) const;
+
+protected:
+    std::pair<std::vector<double>, std::vector<double>>
+        generatedPoints; //!< Points describing the generated curve. Will be set after a call to
+                         //!< getCurve
+
+    const Graph *testGraph; //!< Used to evaluate the binary predictions at the thresholds
+
+    std::vector<LinkPredictor::prediction> predictions; //!< Predictions that should be evaluated
+
+    std::vector<index> thresholds; //!< Indices for the thresholds to use. All node-pairs with an
+                                   //!< index < thresholds[i] will be regarded as links
+
+    count numPositives; //!< Absolute number of positive instances in the prediction-set
+
+    count numNegatives; //!< Absolute number of negative instances in the prediction-set
+
+    std::vector<count> truePositives; //!< True positives regarding the corresponding threshold
+
+    std::vector<count> falsePositives; //!< False positives regarding the corresponding threshold
+
+    std::vector<count> trueNegatives; //!< True negatives regarding the corresponding threshold
+
+    std::vector<count> falseNegatives; //!< False negatives regarding the corresponding threshold
+
+public:
+    EvaluationMetric();
+
+    /**
+     *
+     * @param testGraph Graph containing the links to use for evaluation
+     * @param predictions Dyad-score-pairs whose prediction quality will be evaluated
+     */
+    explicit EvaluationMetric(const Graph &testGraph);
+
+    /**
+     * Default destructor.
+     */
+    virtual ~EvaluationMetric() = default;
+
+    /**
+     * Sets a new graph to use as ground truth for evaluation.
+     * Note that this won't reset the most recently calculated curve and as a consequence
+     * getAreaUnderCurve() const will still behave as expected by returning the AUC of the most
+     * recent curve.
+     * @param newTestGraph New graph to use as ground truth
+     */
+    void setTestGraph(const Graph &newTestGraph);
+
+    /**
+     * Returns a pair of X- and Y-vectors describing the evaluation curve generated from the @a
+     * predictions. The latest y-value will be used as a tie-breaker in case there are multiple
+     * y-values for one x-value. Note that the given number of thresholds (@a numThresholds) is an
+     * upper bound for the number of points returned. This is due to the fact that multiple y-values
+     * can map to one x-value in which case the tie-breaking behavior described above will
+     * intervene.
+     * @param predictions Predictions to evaluate
+     * @param numThresholds The number of thresholds to use the metric on
+     * @return a pair of vectors where the first vectors contains all x-values and the second one
+     * contains the corresponding y-value
+     */
+    virtual std::pair<std::vector<double>, std::vector<double>>
+    getCurve(std::vector<LinkPredictor::prediction> predictions, count numThresholds = 1000);
+
+    /**
+     * Returns the area under the given @a curve by using the trapezoidal rule.
+     * @param curve Curve whose AUC to determine
+     * @return the area under the given curve
+     */
+    virtual double
+    getAreaUnderCurve(std::pair<std::vector<double>, std::vector<double>> curve) const;
+
+    /**
+     * Returns the area under the curve that was most recently calculated by this instance.
+     * This implies that getCurve() has to get called beforehand.
+     * @return area under the most recently calculated curve
+     */
+    virtual double getAreaUnderCurve() const;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_LINKPREDICTION_EVALUATION_METRIC_HPP_