@ladybugmem/icebug 0.1.0 → 0.1.1

package/vendor/include/networkit/matching/Matcher.hpp

@@ -1,55 +0,0 @@
-/*
- * Matcher.hpp
- *
- *  Created on: 30.10.2012
- *      Author: Christian Staudt
- */
-
-#ifndef NETWORKIT_MATCHING_MATCHER_HPP_
-#define NETWORKIT_MATCHING_MATCHER_HPP_
-
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/matching/Matching.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup matching
- * Abstract base class for matching algorithms.
- */
-class Matcher : public Algorithm {
-protected:
-    const Graph *G;
-    Matching M;
-    bool edgeScoresAsWeights; //<! if true, algorithm should use edge scores instead of edge weights
-    const std::vector<double>
-        edgeScores; //<! optional edge scores to be used instead of edge weight
-
-public:
-    /**
-     * Constructor.
-     * @param[in] G Graph for which matching is to be computed.
-     */
-    Matcher(const Graph &G);
-
-    /**
-     * Constructor.
-     * @param[in] G Graph for which matching is to be computed.
-     * @param edgeScores 	(optional) to be used instead of weights
-     */
-    Matcher(const Graph &G, const std::vector<double> &edgeScores);
-
-    /** Default destructor */
-    ~Matcher() override = default;
-
-    /**
-     * Run the matching algorithm on the stored graph and return a matching.
-     * @return A matching of the stored graph.
-     */
-    void run() override = 0;
-
-    Matching getMatching() const;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_MATCHING_MATCHER_HPP_

package/vendor/include/networkit/matching/Matching.hpp

@@ -1,111 +0,0 @@
-/*
- * Matching.hpp
- *
- *  Created on: 03.12.2012
- */
-
-#ifndef NETWORKIT_MATCHING_MATCHING_HPP_
-#define NETWORKIT_MATCHING_MATCHING_HPP_
-
-#include <networkit/auxiliary/Log.hpp>
-#include <networkit/graph/Graph.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup matching
- */
-class Matching {
-
-public:
-    /**
-     * Construct new Matching.
-     *
-     * @param[in]  z  Maximum number of nodes.
-     */
-    Matching(count z = 0);
-
-    /**
-     * Set two nodes @a u and @a v as each others matching partners.
-     *
-     * @param[in] u node.
-     * @param[in] v node.
-     */
-    void match(node u, node v);
-
-    /**
-     * Reset the two nodes @a u and @a v to unmatched.
-     *
-     * @param[in] u node.
-     * @param[in] v node.
-     */
-    void unmatch(node u, node v);
-
-    /**
-     * Check if node is matched.
-     *
-     * @param[in]  u   node.
-     * @return @c true if u is matched.
-     */
-    bool isMatched(node u) const;
-
-    /**
-     * Check if the two nodes @a u and @a v are matched together.
-     *
-     * @param[in] u node.
-     * @param[in] v node.
-     * @return @c true if u and v are matched together.
-     */
-    bool areMatched(node u, node v) const;
-
-    /**
-     * Check whether this is a proper matching
-     * in the graph, i.e. no two matched edges are adjacent.
-     *
-     * @param[in] G  A graph.
-     * @return @c true if this is a proper matching.
-     */
-    bool isProper(const Graph &G) const;
-
-    /**
-     * Get the number of edges in this matching.
-     * @param[in] G  A graph.
-     * @return Number of edges in matching.
-     */
-    count size(const Graph &G) const;
-
-    /**
-     * Get the matched neighbor of @a v if it exists, otherwise @c none.
-     *
-     * @param[in] v node.
-     * @return Mate of @a v if it exists, otherwise none.
-     */
-    index mate(node v) const;
-
-    /**
-     * Get total weight of edges in this matching.
-     * @param[in] g The corresponding graph.
-     * @return Total weight of edges in this matching.
-     */
-    edgeweight weight(const Graph &G) const;
-
-    /**
-     * Convert matching to a Partition object where matched nodes
-     * belong to the same subset and unmatched nodes belong to a singleton subset.
-     * @return Partition
-     */
-    Partition toPartition(const Graph &G) const;
-
-    /**
-     * Get the actual vector storing the data.
-     * @return vector
-     */
-    std::vector<node> getVector() const;
-
-protected:
-    std::vector<node> data; //!< storage of matching nodes
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_MATCHING_MATCHING_HPP_

package/vendor/include/networkit/matching/PathGrowingMatcher.hpp

@@ -1,46 +0,0 @@
-/*
- * PathGrowingMatcher.hpp
- *
- *  Created on: Jun 13, 2013
- *      Author: Henning
- */
-
-#ifndef NETWORKIT_MATCHING_PATH_GROWING_MATCHER_HPP_
-#define NETWORKIT_MATCHING_PATH_GROWING_MATCHER_HPP_
-
-#include <networkit/matching/Matcher.hpp>
-#include <networkit/matching/Matching.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup matching
- * Path growing matching algorithm as described by
- * Hougardy and Drake, http://dx.doi.org/10.1016/S0020-0190(02)00393-9
- * Computes an approximate maximum weight matching with guarantee 1/2.
- * (Note that better algorithms in terms of approximation quality exist.)
- */
-class PathGrowingMatcher final : public Matcher {
-    void checkInput() const;
-
-public:
-    /**
-     * @param[in] G Undirected graph with no self-loops for which matching is computed.
-     */
-    PathGrowingMatcher(const Graph &G);
-
-    /**
-     * @param[in] G Undirected graph with no self-loops for which matching is computed.
-     */
-    PathGrowingMatcher(const Graph &G, const std::vector<double> &edgeScores);
-
-    /**
-     * Runs path growing algorithm to compute approximate maximum weight matching
-     * for graph @a G.
-     * @return Matching (at least half as heavy as maximum weight matching).
-     */
-    void run() override;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_MATCHING_PATH_GROWING_MATCHER_HPP_

package/vendor/include/networkit/matching/SuitorMatcher.hpp

@@ -1,62 +0,0 @@
-/*
- *  SuitorMatcher.hpp
- *
- *  Created on: 27.08.2019
- *  Authors: Michal Boron     <michal.s.boron@gmail.com>
- *           Eugenio Angriman <angrimae@hu-berlin.de>
- */
-
-#ifndef NETWORKIT_MATCHING_SUITOR_MATCHER_HPP_
-#define NETWORKIT_MATCHING_SUITOR_MATCHER_HPP_
-
-#include <vector>
-
-#include <networkit/graph/Graph.hpp>
-#include <networkit/matching/Matcher.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup matching
- * Suitor matching finding algorithm.
- */
-class SuitorMatcher final : public Matcher {
-
-    static bool hasEdgesSortedByWeight(const Graph &G);
-
-    void findSuitor(node current);
-    void findSortSuitor(node current);
-
-public:
-    /**
-     * Computes a 1/2-approximation of the maximum (weighted) matching of an undirected graph using
-     * the Suitor algorithm from Manne and Halappanavar presented in "New Effective Multithreaded
-     * Matching Algorithms", IPDPS 2014. The algorithm has two versions: SortSuitor (faster, but
-     * only works on graphs with adjacency lists sorted by non-increasing edge weight) and Suitor
-     * (works on generic graphs). If using SortSuitor, use GrapTools::sortEdgesByWeight(G, true) to
-     * sort the adjacency lists by non-increasing edge weight.
-     *
-     * @param G An undirected graph.
-     * @param sortSuitor If true uses the SortSuitor version, otherwise it uses Suitor.
-     * @param checkSortedEdges If true and sortSuitor is true it checks whether the adjacency lists
-     * of the input graph are sorted by non-increasing edge weight. If they are not, it throws a
-     * std::runtime_error.
-     */
-    SuitorMatcher(const Graph &G, bool sortSuitor = true, bool checkSortedEdges = false);
-
-    ~SuitorMatcher() override = default;
-
-    /**
-     * Runs the algorithm.
-     */
-    void run() override;
-
-private:
-    bool sortSuitor;
-    std::vector<node> suitor;
-    std::vector<edgeweight> ws;
-    std::vector<index> neighborIterators;
-};
-} // namespace NetworKit
-
-#endif // NETWORKIT_MATCHING_SUITOR_MATCHER_HPP_

package/vendor/include/networkit/numerics/ConjugateGradient.hpp

@@ -1,163 +0,0 @@
-/*
- * ConjugateGradient.hpp
- *
- *  Created on: 15.06.2014
- *      Author: Daniel Hoske and Michael Wegner
- */
-
-#ifndef NETWORKIT_NUMERICS_CONJUGATE_GRADIENT_HPP_
-#define NETWORKIT_NUMERICS_CONJUGATE_GRADIENT_HPP_
-
-#include <cstdint>
-#include <utility>
-
-#include <networkit/algebraic/CSRMatrix.hpp>
-#include <networkit/algebraic/Vector.hpp>
-#include <networkit/numerics/LinearSolver.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup numerics
- * Implementation of Conjugate Gradient.
- */
-template <class Matrix, class Preconditioner>
-class ConjugateGradient : public LinearSolver<Matrix> {
-public:
-    ConjugateGradient(double tolerance = 1e-5)
-        : LinearSolver<Matrix>(tolerance), matrix(Matrix()) {}
-
-    void setup(const Matrix &matrix) override {
-        this->matrix = matrix;
-        precond = Preconditioner(matrix);
-    }
-
-    void setupConnected(const Matrix &matrix) override {
-        this->matrix = matrix;
-        precond = Preconditioner(matrix);
-    }
-
-    /**
-     * Solves the linear system \f$Ax = b\f$ using the conjugate gradient method
-     * with a given preconditioner and with initial value \f$(0, \dots, 0)^T\f$.
-     * We the return the solution \f$x\f$. The solution \f$x\f$ fulfils
-     * \f$\frac{\Vert Ax - b\Vert}{\Vert b \Vert} \leq relative\_residual\f$ if the
-     * algorithm has converged.
-     *
-     * Obviously, @a A needs to have the same number of rows as @a b and
-     * @a status.residual must be nonnegative. You may also request that the algorithm
-     * does not run for more than @a status.max_iters iterations.
-     */
-    SolverStatus solve(const Vector &rhs, Vector &result, count maxConvergenceTime = 5 * 60 * 1000,
-                       count maxIterations = std::numeric_limits<count>::max()) const override;
-
-    /**
-     * Solves the linear systems in parallel.
-     * @param rhs
-     * @param results
-     * @param maxConvergenceTime
-     * @param maxIterations
-     */
-    std::vector<SolverStatus>
-    parallelSolve(const std::vector<Vector> &rhs, std::vector<Vector> &results,
-                  count maxConvergenceTime = 5 * 60 * 1000,
-                  count maxIterations = std::numeric_limits<count>::max()) const override;
-
-    /**
-     * Abstract parallel solve function that computes and processes results using @a resultProcessor
-     * for the matrix currently setup and the right-hand sides (size of @a rhsSize) provided by @a
-     * rhsLoader. The maximum spent time for each system can be specified by @a maxConvergenceTime
-     * and the maximum number of iterations can be set by @a maxIterations.
-     * @param rhsLoader
-     * @param resultProcessor
-     * @param rhsSize
-     * @param maxConvergenceTime
-     * @param maxIterations
-     * @note If the solver does not support parallelism during solves, this function falls back to
-     * solving the systems sequentially.
-     */
-    template <typename RHSLoader, typename ResultProcessor>
-    void parallelSolve(const RHSLoader &rhsLoader, const ResultProcessor &resultProcessor,
-                       std::pair<count, count> rhsSize, count maxConvergenceTime = 5 * 60 * 1000,
-                       count maxIterations = std::numeric_limits<count>::max()) {
-        const index numThreads = omp_get_max_threads();
-        count n = rhsSize.first;
-        count m = rhsSize.second;
-        std::vector<Vector> results(numThreads, Vector(m));
-        std::vector<Vector> RHSs(numThreads, Vector(m));
-
-#pragma omp parallel for
-        for (omp_index i = 0; i < static_cast<omp_index>(n); ++i) {
-            index threadId = omp_get_thread_num();
-            const Vector &rhs = rhsLoader(i, RHSs[threadId]);
-            Vector &result = results[threadId];
-
-            this->solve(rhs, result, maxConvergenceTime, maxIterations);
-            resultProcessor(i, result);
-        }
-    }
-
-private:
-    Matrix matrix;
-    Preconditioner precond;
-};
-
-template <class Matrix, class Preconditioner>
-SolverStatus ConjugateGradient<Matrix, Preconditioner>::solve(const Vector &rhs, Vector &result,
-                                                              count, count maxIterations) const {
-    assert(matrix.numberOfRows() == rhs.getDimension());
-
-    // Absolute residual to achieve
-    double sqr_desired_residual = this->tolerance * this->tolerance * (rhs.length() * rhs.length());
-
-    // Main loop. See:
-    // http://en.wikipedia.org/wiki/Conjugate_gradient_method#The_resulting_algorithm
-    Vector residual_dir = rhs - matrix * result;
-    Vector conjugate_dir = precond.rhs(residual_dir);
-    double sqr_residual = Vector::innerProduct(residual_dir, residual_dir);
-    double sqr_residual_precond = Vector::innerProduct(residual_dir, conjugate_dir);
-
-    count niters = 0;
-    Vector tmp, residual_precond;
-    while (sqr_residual > sqr_desired_residual) {
-        niters++;
-        if (niters > maxIterations) {
-            break;
-        }
-
-        tmp = matrix * conjugate_dir;
-        double step = sqr_residual_precond / Vector::innerProduct(conjugate_dir, tmp);
-        result += step * conjugate_dir;
-        residual_dir -= step * tmp;
-        sqr_residual = Vector::innerProduct(residual_dir, residual_dir);
-
-        residual_precond = precond.rhs(residual_dir);
-        double new_sqr_residual_precond = Vector::innerProduct(residual_dir, residual_precond);
-        conjugate_dir =
-            (new_sqr_residual_precond / sqr_residual_precond) * conjugate_dir + residual_precond;
-        sqr_residual_precond = new_sqr_residual_precond;
-    }
-
-    SolverStatus status;
-    status.numIters = niters;
-    status.residual = (rhs - matrix * result).length();
-    status.converged = status.residual / rhs.length() <= this->tolerance;
-
-    return status;
-}
-
-template <class Matrix, class Preconditioner>
-std::vector<SolverStatus> ConjugateGradient<Matrix, Preconditioner>::parallelSolve(
-    const std::vector<Vector> &rhs, std::vector<Vector> &results, count maxConvergenceTime,
-    count maxIterations) const {
-    std::vector<SolverStatus> stati(rhs.size());
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(rhs.size()); ++i) {
-        stati[i] = this->solve(rhs[i], results[i], maxConvergenceTime, maxIterations);
-    }
-    return stati;
-}
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_NUMERICS_CONJUGATE_GRADIENT_HPP_

package/vendor/include/networkit/numerics/GaussSeidelRelaxation.hpp

@@ -1,99 +0,0 @@
-/*
- * GaussSeidelRelaxation.hpp
- *
- *  Created on: 27.10.2014
- *      Author: Michael Wegner (michael.wegner@student.kit.edu)
- */
-
-#ifndef NETWORKIT_NUMERICS_GAUSS_SEIDEL_RELAXATION_HPP_
-#define NETWORKIT_NUMERICS_GAUSS_SEIDEL_RELAXATION_HPP_
-
-#include <networkit/numerics/Smoother.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup numerics
- * Implementation of the Gauss-Seidel smoother.
- */
-template <class Matrix>
-class GaussSeidelRelaxation : public Smoother<Matrix> {
-
-private:
-    double tolerance;
-
-public:
-    /**
-     * Constructs a Gauss-Seidel smoother with the given @a tolerance (default: 1e-15).
-     * @param tolerance
-     */
-    GaussSeidelRelaxation(double tolerance = 1e-15) : tolerance(tolerance) {}
-
-    /**
-     * Utilizes Gauss-Seidel relaxations until the given number of @a maxIterations is reached or
-     * the relative residual is below the tolerance specified in the constructor. The solver starts
-     * with @a initialGuess as intitial guess to the solution.
-     * @param A The matrix.
-     * @param b The right-hand-side.
-     * @param initialGuess
-     * @param maxIterations
-     * @return The (approximate) solution to the system.
-     */
-    Vector relax(const Matrix &A, const Vector &b, const Vector &initialGuess,
-                 count maxIterations = std::numeric_limits<count>::max()) const override;
-
-    /**
-     * Utilizes Gauss-Seidel relaxations until the given number of @a maxIterations is reached or
-     * the relative residual is below the tolerance specified in the constructor.
-     * @param A The matrix.
-     * @param b The right-hand-side.
-     * @param maxIterations
-     * @return The (approximate) solution to the system.
-     */
-    Vector relax(const Matrix &A, const Vector &b,
-                 count maxIterations = std::numeric_limits<count>::max()) const override;
-};
-
-template <class Matrix>
-Vector GaussSeidelRelaxation<Matrix>::relax(const Matrix &A, const Vector &b,
-                                            const Vector &initialGuess,
-                                            const count maxIterations) const {
-    count iterations = 0;
-    Vector x_old = initialGuess;
-    Vector x_new = initialGuess;
-    if (maxIterations == 0)
-        return initialGuess;
-
-    count dimension = A.numberOfColumns();
-    Vector diagonal = A.diagonal();
-
-    do {
-        x_old = x_new;
-
-        for (index i = 0; i < dimension; ++i) {
-            double sigma = 0.0;
-            A.forNonZeroElementsInRow(i, [&](index column, double value) {
-                if (column != i) {
-                    sigma += value * x_new[column];
-                }
-            });
-
-            x_new[i] = (b[i] - sigma) / diagonal[i];
-        }
-
-        iterations++;
-    } while (iterations < maxIterations && (A * x_new - b).length() / b.length() > tolerance);
-
-    return x_new;
-}
-
-template <class Matrix>
-Vector GaussSeidelRelaxation<Matrix>::relax(const Matrix &A, const Vector &b,
-                                            const count maxIterations) const {
-    Vector x(b.getDimension());
-    return relax(A, b, x, maxIterations);
-}
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_NUMERICS_GAUSS_SEIDEL_RELAXATION_HPP_

package/vendor/include/networkit/numerics/LAMG/LAMGSettings.hpp

@@ -1,70 +0,0 @@
-/*
- * LAMGSettings.hpp
- *
- *  Created on: 09.01.2015
- *      Author: Michael
- */
-
-#ifndef NETWORKIT_NUMERICS_LAMG_LAMG_SETTINGS_HPP_
-#define NETWORKIT_NUMERICS_LAMG_LAMG_SETTINGS_HPP_
-
-#include <networkit/Globals.hpp>
-
-namespace NetworKit {
-
-// #initial test vectors (TVs) at each level.
-constexpr count TV_NUM = 4;
-// #TVs to add upon each aggregation coarsening
-constexpr count TV_INC = 1;
-// maximum allowed#TVs
-constexpr count TV_MAX = 10;
-// #global sweeps to perform on each initial TV
-constexpr count SETUP_TV_SWEEPS = 4;
-// max size for direct solver
-constexpr count MAX_DIRECT_SOLVE_SIZE = 200;
-// maximum #aggregation coarsening levels to construct during the setup phase
-constexpr count SETUP_MAX_AGG_LEVELS = 100;
-// maximum TOTAL # of coarsening levels to construct during the setup phase
-constexpr count SETUP_MAX_LEVELS = 100;
-// solution cycle index. Also the design cycle index during setup phase.
-constexpr double SETUP_CYCLE_INDEX = 1.5;
-// minimum number of sweeps to run to estimate relax ACF
-constexpr count SETUP_RELAX_ACF_MIN_SWEEPS = 7;
-// if relaxation converges at this rate or faster, this becomes the CoarsestLevel
-constexpr double SETUP_MAX_COARSE_RELAX_ACF = 0.3;
-
-constexpr count MAX_COMBINED_ITERATES = 4;
-
-/**************************
- * SETUP - Elimination    *
- **************************/
-
-// maximum degree up to which a node gets eliminated
-constexpr count SETUP_ELIMINATION_MAX_DEGREE = 4;
-// maximum number of elimination stages
-constexpr count SETUP_ELIMINATION_MAX_STAGES = 1000;
-// node elimination stops if number of coarse nodes is only this fraction of the initial number of
-// nodes
-constexpr double SETUP_ELIMINATION_MIN_ELIM_FRACTION = 0.01;
-
-/**************************
- * SETUP - Aggregation    *
- **************************/
-
-constexpr double SETUP_AGGREGATION_WEAK_EDGE_THRESHOLD = 0.1;
-// all nodes with a degree equal or higher than this threshold are marked as high-degree nodes
-constexpr count SETUP_AGGREGATION_DEGREE_THRESHOLD = 8;
-// #sweeps (nu) to use during coarsening stages
-constexpr count SETUP_NU_DEFAULT = 3;
-
-constexpr double SETUP_COARSENING_WORK_GUARD = 0.7;
-
-constexpr count SETUP_MIN_AGGREGATION_STAGES = 1;
-
-constexpr count SETUP_MAX_AGGREGATION_STAGES = 2;
-
-constexpr count SETUP_RELAX_COARSEST_SWEEPS = 400;
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_NUMERICS_LAMG_LAMG_SETTINGS_HPP_