@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,460 +0,0 @@
-/*
- * Lamg.hpp
- *
- *  Created on: Oct 20, 2015
- *      Author: Michael Wegner (michael.wegner@student.kit.edu)
- */
-
-#ifndef NETWORKIT_NUMERICS_LAMG_LAMG_HPP_
-#define NETWORKIT_NUMERICS_LAMG_LAMG_HPP_
-
-#include <omp.h>
-#include <vector>
-
-#include <networkit/algebraic/MatrixTools.hpp>
-#include <networkit/components/ParallelConnectedComponents.hpp>
-#include <networkit/numerics/GaussSeidelRelaxation.hpp>
-#include <networkit/numerics/LAMG/LevelHierarchy.hpp>
-#include <networkit/numerics/LAMG/MultiLevelSetup.hpp>
-#include <networkit/numerics/LAMG/SolverLamg.hpp>
-#include <networkit/numerics/LinearSolver.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup numerics
- * Represents the interface to the Lean Algebraic Multigrid (LAMG) graph Laplacian linear solver
- * by Oren E. Livne and Achi Brandt.
- * @see Livne, Oren E., and Achi Brandt. "Lean algebraic multigrid (LAMG): Fast graph Laplacian
- * linear solver." SIAM Journal on Scientific Computing 34.4 (2012): B499-B522.
- */
-template <class Matrix>
-class Lamg : public LinearSolver<Matrix> {
-private:
-    // for a graph/matrix with K components and T threads:
-
-    bool validSetup;
-    const GaussSeidelRelaxation<Matrix> smoother;
-    const MultiLevelSetup<Matrix> lamgSetup;
-    Matrix laplacianMatrix;
-    count numComponents;
-
-    // maps a node id from global index (in L) to its node id in the component (block of L) such
-    // that in each component, nodes are indexed from 0 to size(component)-1. Size n
-    // not used in case there is only a single component
-    std::vector<index> graph2Components;
-
-    // for each component, a vector of ids that are in this component. Size K
-    std::vector<std::vector<index>> components;
-    // one LevelHierarchy for each component. Size K
-    std::vector<LevelHierarchy<Matrix>> compHierarchies;
-
-    // these are internal data structures used in the solve function
-    // one object for each component and each thread - access: [thread][component]
-    mutable std::vector<std::vector<SolverLamg<Matrix>>> compSolvers;
-    // one object for each component and each thread - access: [thread][component]
-    mutable std::vector<std::vector<LAMGSolverStatus>> compStati;
-
-    // one object for each component and each thread - access: [thread][component]
-    mutable std::vector<std::vector<Vector>> initialVectors;
-    // one object for each component and each thread - access: [thread][component]
-    mutable std::vector<std::vector<Vector>> rhsVectors;
-
-    // initializing step 1
-    // initializes numComponents, graph2components, components, compHierarchies
-    // precondition: laplacianMatrix is set correctly
-    void initializeOneComponent();
-    void initializeMultipleComponents(const Graph &G, const ComponentDecomposition &decomp);
-
-    // initializing step 2
-    // initializes compSolvers, compStati, initialVectors, rhsVectors
-    // Precondition: the following members are set correctly:
-    // numComponents, components, compHierarchies
-    void initializeInternalDatastructures() const;
-
-    // solves on the given thread
-    SolverStatus solveThread(const Vector &rhs, Vector &result, count maxConvergenceTime,
-                             count maxIterations, index threadId) const;
-
-public:
-    /**
-     * Construct a solver with the given @a tolerance. The relative residual ||Ax-b||/||b|| will be
-     * less than or equal to
-     * @a tolerance after the solver finished.
-     * @param tolerance
-     */
-    Lamg(const double tolerance = 1e-6)
-        : LinearSolver<Matrix>(tolerance), validSetup(false), lamgSetup(smoother),
-          numComponents(0) {}
-    /** Default destructor */
-    ~Lamg() override = default;
-
-    /**
-     * Compute the multigrid hierarchy for the given Laplacian matrix @a laplacianMatrix.
-     * @param laplacianMatrix
-     * @note This method also works for disconnected graphs. If you know that the graph is
-     * connected, it is faster to use @ref setupConnected instead.
-     */
-    void setup(const Matrix &laplacianMatrix) override;
-
-    /**
-     * Compute the multigrid hierarchy for the Laplacian matrix that
-     * corresponds to the graph @a G.
-     * @param laplacianMatrix
-     * @param G Graph that corresponds to the @a laplacianMatrix
-     */
-    void setup(const Graph &graph) override;
-
-    /**
-     * Compute the multigrid hierarchy for the given Laplacian matrix @a laplacianMatrix that
-     * corresponds to the graph @a G.
-     * @param laplacianMatrix
-     * @param G Graph that corresponds to the @a laplacianMatrix
-     * @note This setup method allows you to skip some computation required for setting up LAMG. You
-     * can provide your matrix and graph, which are required for setting up LAMG, via this method to
-     * prevent duplicate computation. Note that the output is undefined if the two parameters do not
-     * correspond the the same graph.
-     */
-    void setup(const Matrix &laplacianMatrix, const Graph &G);
-
-    /**
-     * Compute the multigrid hierarchy for the Laplacian matrix that
-     * corresponds to the graph @a G using the existing component decomposition @a decomp.
-     * @param G Graph that corresponds to the @a laplacianMatrix
-     * @param decomp ComponentDecomposition for the graph @a G
-     * @note This setup method allows you to skip some computation required for setting up LAMG. You
-     * can provide your graph and decomposition, which are required for setting up LAMG, via this
-     * method to prevent duplicate computation. Note that the output is undefined if the two
-     * parameters do not correspond the the same graph.
-     */
-    void setup(const Graph &G, const ComponentDecomposition &decomp);
-
-    /**
-     * Compute the multigrid hierarchy for the given Laplacian matrix @a laplacianMatrix that
-     * corresponds to the graph @a G using the existing component decomposition @a decomp.
-     * @param laplacianMatrix
-     * @param G Graph that corresponds to the @a laplacianMatrix
-     * @param decomp ComponentDecomposition for the graph @a G
-     * @note This setup method allows you to skip some computation required for setting up LAMG. You
-     * can provide your graph and decomposition, which are required for setting up LAMG, via
-     * this method to prevent duplicate computation. Note that the output is undefined if the three
-     * parameters do not correspond the the same graph.
-     */
-    void setup(const Matrix &laplacianMatrix, const Graph &G, const ComponentDecomposition &decomp);
-
-    /**
-     * Compute the multigrid hierarchy for the given Laplacian matrix @a laplacianMatrix.
-     * @param laplacianMatrix
-     * @note The graph has to be connected for this method to work. Otherwise the output is
-     * undefined.
-     */
-    void setupConnected(const Matrix &laplacianMatrix) override;
-
-    /**
-     * Computes the @a result for the matrix currently setup and the right-hand side @a rhs.
-     * The maximum spent time can be specified by @a maxConvergenceTime and the maximum number of
-     * iterations can be set by @a maxIterations.
-     * @param rhs
-     * @param result
-     * @param maxConvergenceTime
-     * @param maxIterations
-     * @return A @ref SolverStatus object which provides some statistics like the final absolute
-     * residual.
-     */
-    SolverStatus solve(const Vector &rhs, Vector &result, count maxConvergenceTime = 5 * 60 * 1000,
-                       count maxIterations = std::numeric_limits<count>::max()) const override;
-
-    /**
-     * Compute the @a results for the matrix currently setup and the right-hand sides @a rhs.
-     * 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 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.
-     * @note The @a rhsLoader and @a resultProcessor are called from multiple threads in parallel.
-     */
-    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 {
-
-        const count n = rhsSize.first;
-        const count m = rhsSize.second;
-        const index numThreads = omp_get_max_threads();
-
-        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) {
-            const index threadId = omp_get_thread_num();
-
-            const Vector &rhs = rhsLoader(i, RHSs[threadId]);
-            Vector &result = results[threadId];
-
-            solveThread(rhs, result, maxConvergenceTime, maxIterations, threadId);
-            resultProcessor(i, result);
-        }
-    }
-};
-
-template <class Matrix>
-void Lamg<Matrix>::initializeInternalDatastructures() const {
-    // preconditions:
-    // - numComponents is correct
-    // - components vector is correct
-    // - compHierarchies is setup
-
-    // first, resize outer vectors
-    // then iterate elements and initialize them correctly
-
-    initialVectors.resize(omp_get_max_threads());
-    rhsVectors.resize(omp_get_max_threads());
-    compSolvers.resize(omp_get_max_threads());
-    compStati.resize(omp_get_max_threads());
-
-#pragma omp parallel for
-    for (int thread = 0; thread < omp_get_max_threads(); ++thread) {
-        // resize inner vectors
-        initialVectors[thread].resize(numComponents);
-        rhsVectors[thread].resize(numComponents);
-        compStati[thread].resize(numComponents);
-
-        // there is no default constructor for SolverLamg - reserve memory and construct later
-        compSolvers[thread].clear();
-        compSolvers[thread].reserve(numComponents);
-
-        // iterate components
-        for (index compIdx = 0; compIdx < numComponents; ++compIdx) {
-            auto &component = components[compIdx];
-
-            // Vector objects do not have a resize method - create new objects instead
-            initialVectors[thread][compIdx] = Vector(component.size());
-            rhsVectors[thread][compIdx] = Vector(component.size());
-
-            compSolvers[thread].emplace_back(compHierarchies[compIdx], smoother);
-
-            LAMGSolverStatus status;
-            status.desiredResidualReduction =
-                this->tolerance * component.size() / laplacianMatrix.numberOfColumns();
-            compStati[thread][compIdx] = status;
-        }
-    }
-}
-
-template <class Matrix>
-void Lamg<Matrix>::initializeOneComponent() {
-    numComponents = 1;
-    components.resize(1);
-    components[0].resize(laplacianMatrix.numberOfColumns());
-    std::iota(components[0].begin(), components[0].end(), 0);
-    graph2Components.clear();
-    compHierarchies = std::vector<LevelHierarchy<Matrix>>(1);
-    lamgSetup.setup(laplacianMatrix, compHierarchies[0]);
-    initializeInternalDatastructures();
-}
-
-template <class Matrix>
-void Lamg<Matrix>::initializeMultipleComponents(const Graph &G,
-                                                const ComponentDecomposition &decomp) {
-
-    numComponents = decomp.numberOfComponents();
-
-    components.resize(numComponents);
-    graph2Components.resize(G.numberOfNodes());
-
-    compHierarchies.resize(numComponents);
-
-    index compIdx = 0;
-    for (const auto &partitionComponent : decomp.getPartition().getSubsets()) {
-        components[compIdx].resize(partitionComponent.size());
-        std::copy(partitionComponent.begin(), partitionComponent.end(),
-                  components[compIdx].begin());
-
-        auto &component = components[compIdx];
-
-        index idx = 0;
-        for (node u : component) {
-            graph2Components[u] = idx;
-            idx++;
-        }
-
-        // it is not clear to me if LevelHierarchy can be reused for different matrices. Hence,
-        // construct new objects
-        compHierarchies[compIdx] = LevelHierarchy<Matrix>();
-
-        // construct block matrix via neighborsOf in G
-        std::vector<Triplet> triplets;
-        for (node u : component) {
-            G.forNeighborsOf(u, [&](node v, edgeweight w) {
-                triplets.push_back({graph2Components[u], graph2Components[v], w});
-            });
-        }
-        Matrix compMatrix(component.size(), component.size(), triplets);
-        lamgSetup.setup(compMatrix, compHierarchies[compIdx]);
-
-        ++compIdx;
-    }
-    initializeInternalDatastructures();
-}
-
-template <class Matrix>
-void Lamg<Matrix>::setupConnected(const Matrix &laplacianMatrix) {
-    assert([&]() {
-        auto G = MatrixTools::matrixToGraph(laplacianMatrix);
-        ParallelConnectedComponents cc(G);
-        cc.run();
-        return cc.numberOfComponents() == 1;
-    }());
-    this->laplacianMatrix = laplacianMatrix;
-    initializeOneComponent();
-    validSetup = true;
-}
-
-template <class Matrix>
-void Lamg<Matrix>::setup(const Matrix &laplacianMatrix, const Graph &G,
-                         const ComponentDecomposition &decomp) {
-    this->laplacianMatrix = laplacianMatrix;
-    numComponents = decomp.numberOfComponents();
-    if (numComponents == 1) {
-        initializeOneComponent();
-    } else {
-        initializeMultipleComponents(G, decomp);
-    }
-    validSetup = true;
-}
-
-template <class Matrix>
-void Lamg<Matrix>::setup(const Graph &G, const ComponentDecomposition &decomp) {
-    setup(Matrix::laplacianMatrix(G), G, decomp);
-}
-
-template <class Matrix>
-void Lamg<Matrix>::setup(const Graph &G) {
-    setup(Matrix::laplacianMatrix(G), G);
-}
-
-template <class Matrix>
-void Lamg<Matrix>::setup(const Matrix &laplacianMatrix, const Graph &G) {
-    ParallelConnectedComponents con(G, false);
-    con.run();
-    setup(laplacianMatrix, G, con);
-}
-
-template <class Matrix>
-void Lamg<Matrix>::setup(const Matrix &laplacianMatrix) {
-    auto G = MatrixTools::matrixToGraph(laplacianMatrix);
-    setup(laplacianMatrix, G);
-}
-
-template <class Matrix>
-SolverStatus Lamg<Matrix>::solveThread(const Vector &rhs, Vector &result, count maxConvergenceTime,
-                                       count maxIterations, const index threadId) const {
-    if (!validSetup)
-        throw std::runtime_error("LAMG is not properly setup!");
-    if (result.getDimension() != laplacianMatrix.numberOfColumns()
-        || rhs.getDimension() != laplacianMatrix.numberOfRows()) {
-        throw std::runtime_error("Wrong matrix dimensions for given vectors.");
-    }
-    SolverStatus status;
-
-    if (numComponents == 1) {
-        LAMGSolverStatus &stat = compStati[threadId][0];
-        stat.desiredResidualReduction =
-            this->tolerance * rhs.length() / (laplacianMatrix * result - rhs).length();
-        stat.maxIters = maxIterations;
-        stat.maxConvergenceTime = maxConvergenceTime;
-        compSolvers[threadId][0].solve(result, rhs, stat);
-
-        status.residual = stat.residual;
-        status.numIters = stat.numIters;
-        status.converged = stat.converged;
-    } else {
-        // solve on every component
-        count maxIters = 0;
-        for (index componentId = 0; componentId < components.size(); ++componentId) {
-            LAMGSolverStatus &stat = compStati[threadId][componentId];
-            Vector &componentRhs = rhsVectors[threadId][componentId];
-            Vector &componentResult = initialVectors[threadId][componentId];
-
-            // setup component vectors
-            for (auto element : components[componentId]) {
-                componentResult[graph2Components[element]] = result[element];
-                componentRhs[graph2Components[element]] = rhs[element];
-            }
-
-            // setup solver status
-            double resReduction =
-                this->tolerance * componentRhs.length()
-                / (compHierarchies[componentId].at(0).getLaplacian() * componentResult
-                   - componentRhs)
-                      .length();
-            stat.desiredResidualReduction =
-                resReduction * components[componentId].size() / laplacianMatrix.numberOfRows();
-            stat.maxIters = maxIterations;
-            stat.maxConvergenceTime = maxConvergenceTime;
-
-            compSolvers[threadId][componentId].solve(componentResult, componentRhs, stat);
-            // write solution back to result
-            for (auto element : components[componentId]) {
-                result[element] = componentResult[graph2Components[element]];
-            }
-
-            maxIters = std::max(maxIters, stat.numIters);
-        }
-
-        status.residual = (rhs - laplacianMatrix * result).length();
-        status.converged = status.residual <= this->tolerance;
-        status.numIters = maxIters;
-    }
-
-    return status;
-}
-
-template <class Matrix>
-SolverStatus Lamg<Matrix>::solve(const Vector &rhs, Vector &result, count maxConvergenceTime,
-                                 count maxIterations) const {
-    return solveThread(rhs, result, maxConvergenceTime, maxIterations, 0);
-}
-
-template <class Matrix>
-std::vector<SolverStatus>
-Lamg<Matrix>::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) {
-        const index threadId = omp_get_thread_num();
-        stati[i] = solveThread(rhs[i], results[i], maxConvergenceTime, maxIterations, threadId);
-    }
-
-    return stati;
-}
-
-extern template class Lamg<CSRMatrix>;
-extern template class Lamg<DenseMatrix>;
-extern template class Lamg<DynamicMatrix>;
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_NUMERICS_LAMG_LAMG_HPP_

package/vendor/include/networkit/numerics/LAMG/Level/EliminationStage.hpp

@@ -1,47 +0,0 @@
-/*
- * EliminationStage.hpp
- *
- *  Created on: 09.01.2015
- *      Author: Michael
- */
-
-#ifndef NETWORKIT_NUMERICS_LAMG_LEVEL_ELIMINATION_STAGE_HPP_
-#define NETWORKIT_NUMERICS_LAMG_LEVEL_ELIMINATION_STAGE_HPP_
-
-#include <networkit/algebraic/Vector.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup numerics
- */
-template <class Matrix>
-class EliminationStage {
-private:
-    Matrix P; // interpolation matrix
-    Matrix R;
-    Vector q; // coarse result correction vector
-    std::vector<index> fSet;
-    std::vector<index> cSet;
-
-public:
-    EliminationStage(const Matrix &P, const Vector &q, const std::vector<index> &fSet,
-                     const std::vector<index> &cSet)
-        : P(P), R(P.transpose()), q(q), fSet(fSet), cSet(cSet) {}
-
-    inline const Matrix &getP() const { return P; }
-
-    inline const Matrix &getR() const { return R; }
-
-    inline const Vector &getQ() const { return q; }
-
-    inline const std::vector<index> &getFSet() const { return fSet; }
-
-    inline const std::vector<index> &getCSet() const { return cSet; }
-
-    inline count getN() const { return fSet.size() + cSet.size(); }
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_NUMERICS_LAMG_LEVEL_ELIMINATION_STAGE_HPP_

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

@@ -1,56 +0,0 @@
-/*
- * Level.hpp
- *
- *  Created on: 09.01.2015
- *      Author: Michael
- */
-
-#ifndef NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_HPP_
-#define NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_HPP_
-
-#include <networkit/algebraic/CSRMatrix.hpp>
-
-namespace NetworKit {
-
-enum LevelType {
-    FINEST,      // original problem
-    ELIMINATION, // lowdegree node elimination
-    AGGREGATION, // aggregation of nodes with high affinity
-    COARSEST     // coarsest level
-};
-
-/**
- * @ingroup numerics
- * Abstract base class for an LAMG Level.
- */
-template <class Matrix>
-class Level {
-protected:
-    LevelType type;
-    Matrix A;
-
-public:
-    Level(LevelType type) : type(type) {}
-    Level(LevelType type, const Matrix &A) : type(type), A(A) {}
-    virtual ~Level() {}
-
-    inline const Matrix &getLaplacian() const { return A; }
-
-    inline count getNumberOfNodes() const { return A.numberOfRows(); }
-
-    virtual void coarseType(const Vector & /*xf*/, Vector & /*xc*/) const {}
-
-    virtual void restrict(const Vector & /*bf*/, Vector & /*bc*/) const {}
-
-    virtual void restrict(const Vector & /*bf*/, Vector & /*bc*/,
-                          std::vector<Vector> & /*bStages*/) const {}
-
-    virtual void interpolate(const Vector & /*xc*/, Vector & /*xf*/) const {}
-
-    virtual void interpolate(const Vector & /*xc*/, Vector & /*xf*/,
-                             const std::vector<Vector> & /*bStages*/) const {}
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_HPP_

package/vendor/include/networkit/numerics/LAMG/Level/LevelAggregation.hpp

@@ -1,52 +0,0 @@
-/*
- * LevelAggregation.hpp
- *
- *  Created on: 10.01.2015
- *      Author: Michael
- */
-
-#ifndef NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_AGGREGATION_HPP_
-#define NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_AGGREGATION_HPP_
-
-#include <networkit/numerics/LAMG/Level/Level.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup numerics
- */
-template <class Matrix>
-class LevelAggregation : public Level<Matrix> {
-private:
-    Matrix P; // interpolation matrix (n x nc)
-    Matrix R; // restriction matrix (nc x n)
-
-public:
-    LevelAggregation(const Matrix &A, const Matrix &P, const Matrix &R)
-        : Level<Matrix>(LevelType::AGGREGATION, A), P(P), R(R) {}
-
-    void coarseType(const Vector &xf, Vector &xc) const override;
-
-    void restrict(const Vector &bf, Vector &bc) const override;
-
-    void interpolate(const Vector &xc, Vector &xf) const override;
-};
-
-template <class Matrix>
-void LevelAggregation<Matrix>::coarseType(const Vector & /*xf*/, Vector &xc) const {
-    xc = Vector(P.numberOfColumns(), 0.0);
-}
-
-template <class Matrix>
-void LevelAggregation<Matrix>::restrict(const Vector &bf, Vector &bc) const {
-    bc = R * bf;
-}
-
-template <class Matrix>
-void LevelAggregation<Matrix>::interpolate(const Vector &xc, Vector &xf) const {
-    xf = P * xc;
-}
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_AGGREGATION_HPP_