@ladybugmem/icebug 0.1.0

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

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

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

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

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

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

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

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