@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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