@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,1090 +0,0 @@
-/*
- * MultiLevelSetup.hpp
- *
- *  Created on: 10.01.2015
- *      Author: Michael Wegner
- */
-
-#ifndef NETWORKIT_NUMERICS_LAMG_MULTI_LEVEL_SETUP_HPP_
-#define NETWORKIT_NUMERICS_LAMG_MULTI_LEVEL_SETUP_HPP_
-
-#include <networkit/algebraic/CSRMatrix.hpp>
-#include <networkit/algebraic/DenseMatrix.hpp>
-#include <networkit/algebraic/DynamicMatrix.hpp>
-#include <networkit/numerics/LAMG/LevelHierarchy.hpp>
-#include <networkit/numerics/Smoother.hpp>
-
-#include <cmath>
-#include <limits>
-#include <vector>
-
-namespace NetworKit {
-
-/**
- * @ingroup
- * Implements the setup phase of LAMG (Lean Algebraic Multigrid by Livne et al.).
- */
-template <class Matrix>
-class MultiLevelSetup {
-
-#define UNDECIDED std::numeric_limits<index>::max()
-
-private:
-    const Smoother<Matrix> &smoother;
-
-    /**
-     * Elimination phase of LAMG for the specified Laplacian matrix @a matrix. If an elemination
-     * stage is created, it is stored in the LevelHierarchy @a hierarchy and the method returns
-     * @code{true}. Otherwise, @code{false} is returned.
-     * @param matrix Laplacian matrix for which an elimination stage should be created.
-     * @param hierarchy LevelHierarchy in which the created elimination stage is stored (if created)
-     * @return @code{True} if an elimination stage has been created, otherwise@code{false}.
-     */
-    bool coarseningElimination(Matrix &matrix, LevelHierarchy<Matrix> &hierarchy) const;
-
-    /**
-     * Scans the Laplacian matrix for nodes with a low degree (i.e. nodes with less than 5
-     * neighbors). For each node having low degree and independent from already found low degree
-     * nodes, @code{true} is stored in @a fNode. The
-     * @a stage parameter specifies if we are in the first or subsequent stages during elimination.
-     * @param matrix Laplacian matrix.
-     * @param fNode[out] For each node, @code{true} if the node is of low degree and @code{false}
-     * otherwise.
-     * @param stage The stage of the elimination phase.
-     * @return Number of low degree nodes found.
-     */
-    count lowDegreeSweep(const Matrix &matrix, std::vector<bool> &fNode, index stage) const;
-
-    /**
-     * Computes the projection matrix @a P and the @a q vector used to restrict and interpolate the
-     * matrix for an elimination stage.
-     * @param matrix Laplacian matrix.
-     * @param fSet Set of nodes having low degree.
-     * @param coarseIndex Set of nodes equal to V \setminus fSet
-     * @param P[out] The projection matrix.
-     * @param q[out] The q vector.
-     */
-    void eliminationOperators(const Matrix &matrix, const std::vector<index> &fSet,
-                              const std::vector<index> &coarseIndex, Matrix &P, Vector &q) const;
-
-    /**
-     * Aggregation phase of LAMG for the specified Laplacian matrix @a matrix. The coarsened matrix
-     * is stored in the LevelHierarchy @a hierarchy. The test vector @a tv is used for determining
-     * the affinity of nodes. The parameter
-     * @a numTVVectors specifies how many test vectors will be created to determine the affinities
-     * between nodes.
-     * @param matrix Laplacian matrix.
-     * @param hierarchy LevelHierarchy to store the stage.
-     * @param tv Test vector.
-     * @param numTVVectors Number of test vectors to use.
-     */
-    void coarseningAggregation(Matrix &matrix, LevelHierarchy<Matrix> &hierarchy, Vector &tv,
-                               count numTVVectors) const;
-
-    /**
-     * Create @a numVectors test vectors for the given Laplacian matrix @a matrix. The test vector
-     * @a tv will be reused.
-     * @param matrix Laplacian matrix.
-     * @param tv Test vector.
-     * @param numVectors Number of test vectors to create.
-     * @return The created test vectors.
-     */
-    std::vector<Vector> generateTVs(const Matrix &matrix, Vector &tv, count numVectors) const;
-
-    /**
-     * Adds high degree nodes as seeds to @a status.
-     * @param matrix Laplacian matrix.
-     * @param status[out] High degree nodes are flagged as seed.
-     */
-    void addHighDegreeSeedNodes(const Matrix &matrix, std::vector<index> &status) const;
-
-    /**
-     * Aggregates loose nodes (nodes with low adjacency) together.
-     * @param strongAdjMatrix Strong adjacency matrix.
-     * @param status[out] Aggregates loose nodes together and labels them in @a status accordingly.
-     * @param nc[out] The altered number of coarse nodes.
-     */
-    void aggregateLooseNodes(const Matrix &strongAdjMatrix, std::vector<index> &status,
-                             count &nc) const;
-
-    /**
-     * Computes the strong adjacency matrix for the given Laplacian matrix @a matrix.
-     * @param matrix Laplacian matrix.
-     * @param strongAdjMatrix[out] The resulting strong adjacency matrix.
-     */
-    void computeStrongAdjacencyMatrix(const Matrix &matrix, Matrix &strongAdjMatrix) const;
-
-    /**
-     * Computes the affinity matrix for the given Laplacian matrix @a matrix and the test vectors @a
-     * tVs.
-     * @param matrix Laplacian matrix.
-     * @param tVs Test vectors.
-     * @param affinityMatrix[out] The resulting affinity matrix.
-     */
-    void computeAffinityMatrix(const Matrix &matrix, const std::vector<Vector> &tVs,
-                               Matrix &affinityMatrix) const;
-
-    /**
-     * Models one stage in the aggregation phase. New aggregates are labeled accordingly in @a
-     * status.
-     * @param matrix Laplacian matrix.
-     * @param nc Number of coarse nodes.
-     * @param strongAdjMatrix Strong adjacency matrix.
-     * @param affinityMatrix Affinity matrix.
-     * @param tVs[out] Test vectors.
-     * @param status[out] Aggregation labels.
-     */
-    void aggregationStage(const Matrix &matrix, count &nc, const Matrix &strongAdjMatrix,
-                          const Matrix &affinityMatrix, std::vector<Vector> &tVs,
-                          std::vector<index> &status) const;
-
-    /**
-     * Computes strong (cf. LAMG paper) neighbors and stores them sorted into @a bins.
-     * @param affinityMatrix Affinity matrix.
-     * @param status Aggregation labels.
-     * @param bins[out] Strong neighbors sorted into bins.
-     */
-    void computeStrongNeighbors(const Matrix &affinityMatrix, const std::vector<index> &status,
-                                std::vector<std::vector<index>> &bins) const;
-
-    /**
-     * Finds the best seed for node @a u and stores it in @a s.
-     * @param strongAdjMatrix
-     * @param affinityMatrix Affinity matrix.
-     * @param diag Vector of diagonal entries of the Laplacian matrix.
-     * @param tVs Test vectors.
-     * @param status Aggregation labels.
-     * @param u The node to find the best seed for.
-     * @param s[out] The best seed for node @a u.
-     * @return @code{True} if a seed has been found for @a u, @code{false} otherwise.
-     */
-    bool findBestSeedEnergyCorrected(const Matrix &strongAdjMatrix, const Matrix &affinityMatrix,
-                                     const std::vector<double> &diag,
-                                     const std::vector<Vector> &tVs,
-                                     const std::vector<index> &status, index u, index &s) const;
-
-    /**
-     * Determines if the Laplacian matrix @a A can be coarsened further.
-     * @param A Laplacian matrix.
-     * @return @code{True} if @a A can be coarsened further, @code{false} otherwise.
-     */
-    inline bool canCoarsen(const Matrix &A) const {
-        return A.numberOfRows() > MAX_DIRECT_SOLVE_SIZE;
-    }
-
-    /**
-     * Determines if the relaxation is fast enough to stop coarsening.
-     * @param A Laplacian matrix.
-     * @param lvlIndex The number of levels already created in the hierarchy.
-     * @param tv Test vector.
-     * @return @code{True} if convergence of relaxation is fast, @code{false} otherwise.
-     */
-    bool isRelaxationFast(const Matrix &A, index lvlIndex, Vector &tv) const;
-
-    /**
-     * Computes the coarsened matrix of @a matrix by means of the projection matrix @a P and stores
-     * the result in @a B.
-     * @param P Projection matrix.
-     * @param A Laplacian matrix.
-     * @param PColIndex Stores the column index of the 1 entry at each row.
-     * @param PRowIndex Stores the row index of the 1 entry at each column.
-     * @param B[out] Resulting coarsened Laplacian matrix.
-     */
-    void galerkinOperator(const Matrix &P, const Matrix &A, const std::vector<index> &PColIndex,
-                          const std::vector<std::vector<index>> &PRowIndex, Matrix &B) const;
-
-    /**
-     * Creates a @a hierarchy for the given Laplacian matrix @a matrix.
-     * @param matrix Laplcian matrix.
-     * @param hierarchy[out] The constructed hierarchy.
-     */
-    void setupForMatrix(Matrix &matrix, LevelHierarchy<Matrix> &hierarchy) const;
-
-public:
-    /**
-     * Creates an instance of MultiLevelSetup with the specified @a smoother used for relaxing
-     * during the setup phase.
-     * @param smoother Reference to smoother.
-     */
-    MultiLevelSetup(const Smoother<Matrix> &smoother) : smoother(smoother) {}
-
-    /**
-     * Creates a @ hierarchy for the given Laplacian matrix of the graph @a G.
-     * @param G The graph.
-     * @param hierarchy[out] The constructed hierarchy.
-     */
-    void setup(const Graph &G, LevelHierarchy<Matrix> &hierarchy) const {
-        setup(Matrix::laplacianMatrix(G), hierarchy);
-    }
-
-    /**
-     * Creates a @a hierarchy for the given Laplacian matrix @a matrix.
-     * @param matrix Laplcian matrix.
-     * @param hierarchy[out] The constructed hierarchy.
-     */
-    void setup(Matrix matrix, LevelHierarchy<Matrix> &hierarchy) const;
-};
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::setup(Matrix matrix, LevelHierarchy<Matrix> &hierarchy) const {
-    setupForMatrix(matrix, hierarchy);
-}
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::setupForMatrix(Matrix &A, LevelHierarchy<Matrix> &hierarchy) const {
-    hierarchy.addFinestLevel(A);
-
-#ifndef NDEBUG
-    DEBUG("FINEST\t", A.numberOfRows(), "\t", A.nnz());
-#endif // NDEBUG
-
-    bool doneCoarsening = false;
-    count numTVs = TV_NUM;
-    index level = 0;
-
-    while (!doneCoarsening) {
-        // ELIMINATION
-        if (coarseningElimination(A, hierarchy)) {
-            if (!canCoarsen(A))
-                doneCoarsening = true;
-            level++;
-#ifndef NDEBUG
-            DEBUG(level, " ELIM\t\t", A.numberOfRows(), "\t", A.nnz() / 2);
-#endif // NDEBUG
-        }
-
-        // AGGREGATION
-        Vector tv;
-        if (doneCoarsening || isRelaxationFast(A, level, tv)) {
-            doneCoarsening = true;
-        } else {
-            coarseningAggregation(A, hierarchy, tv, numTVs);
-            level++;
-#ifndef NDEBUG
-            DEBUG(level, " AGG\t\t", A.numberOfRows(), "\t", A.nnz() / 2);
-#endif // NDEBUG
-            if (numTVs < TV_MAX) {
-                numTVs += TV_INC;
-            }
-        }
-
-        if (!canCoarsen(A))
-            doneCoarsening = true;
-    }
-
-    hierarchy.setLastAsCoarsest();
-}
-
-template <class Matrix>
-bool MultiLevelSetup<Matrix>::coarseningElimination(Matrix &matrix,
-                                                    LevelHierarchy<Matrix> &hierarchy) const {
-    std::vector<EliminationStage<Matrix>> coarseningStages;
-    count stageNum = 0;
-    while (stageNum < SETUP_ELIMINATION_MAX_STAGES) {
-        if (matrix.numberOfRows() <= MAX_DIRECT_SOLVE_SIZE)
-            break; // we do not need to coarsen the matrix any further
-        std::vector<bool> fNode;
-        count nf = lowDegreeSweep(matrix, fNode, stageNum);
-        count nc = matrix.numberOfRows() - nf;
-
-        if (nc == 0) { // do not eliminate all nodes -> leave one entry in c
-            nc = 1;
-            nf--;
-        }
-
-        // add f nodes to fSet and c nodes to cSet
-        std::vector<index> fSet(nf);
-        std::vector<index> cSet(nc);
-
-        std::vector<index> coarseIndex(matrix.numberOfRows());
-        for (index i = 0, fIndex = 0, cIndex = 0; i < matrix.numberOfRows(); ++i) {
-            if (fNode[i] && fIndex < nf) {
-                coarseIndex[i] = fIndex;
-                fSet[fIndex++] = i;
-            } else {
-                coarseIndex[i] = cIndex;
-                cSet[cIndex++] = i;
-            }
-        }
-
-        if (nf <= SETUP_ELIMINATION_MIN_ELIM_FRACTION * matrix.numberOfRows()) {
-            break;
-        }
-
-        Matrix P;
-        Vector q;
-        eliminationOperators(matrix, fSet, coarseIndex, P, q);
-        coarseningStages.push_back(EliminationStage<Matrix>(P, q, fSet, cSet));
-
-        Matrix Acc = matrix.extract(cSet, cSet); // Schur complement
-        Matrix Acf = matrix.extract(cSet, fSet); // Schur complement
-
-        matrix = Acc + Acf * P;
-        stageNum++;
-    }
-
-    if (stageNum != 0) { // we have coarsened the matrix
-        hierarchy.addEliminationLevel(matrix, coarseningStages);
-        return true;
-    }
-
-    return false;
-}
-
-template <class Matrix>
-count MultiLevelSetup<Matrix>::lowDegreeSweep(const Matrix &matrix, std::vector<bool> &fNode,
-                                              index stage) const {
-    fNode.resize(matrix.numberOfRows(), true); // first mark all nodes as f nodes
-    count numFNodes = 0;
-    int degreeOffset = stage != 0;
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        if ((int)matrix.nnzInRow(i) - degreeOffset <= (int)SETUP_ELIMINATION_MAX_DEGREE
-            && fNode[i]) { // node i has degree <= 4 and can be eliminated
-            numFNodes++;
-            // To maintain independence, mark all neighbors  as not eliminated all neighbors of this
-            // f node are c nodes
-            matrix.forNonZeroElementsInRow(i, [&](index j, edgeweight /*w*/) {
-                if (j != i) {
-                    fNode[j] = false;
-                }
-            });
-        } else { // Node has high degree, thus it is a c node
-            fNode[i] = false;
-        }
-    }
-
-    return numFNodes;
-}
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::eliminationOperators(const Matrix &matrix,
-                                                   const std::vector<index> &fSet,
-                                                   const std::vector<index> &coarseIndex, Matrix &P,
-                                                   Vector &q) const {
-    std::vector<Triplet> triples;
-    q = Vector(fSet.size());
-    for (index k = 0; k < fSet.size(); ++k) { // Afc
-        matrix.forNonZeroElementsInRow(fSet[k], [&](index j, edgeweight w) {
-            if (fSet[k] == j) {
-                q[k] = 1.0 / w;
-            } else {
-                triples.push_back({k, coarseIndex[j], w});
-            }
-        });
-    }
-
-    for (index i = 0; i < triples.size(); ++i) { // * -Aff^-1
-        triples[i].value *= -q[triples[i].row];
-    }
-
-    P = Matrix(fSet.size(), coarseIndex.size() - fSet.size(), triples);
-}
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::coarseningAggregation(Matrix &matrix,
-                                                    LevelHierarchy<Matrix> &hierarchy, Vector &tv,
-                                                    count numTVVectors) const {
-    Vector B(SETUP_MAX_AGGREGATION_STAGES, std::numeric_limits<double>::max());
-    std::vector<std::vector<index>> S(
-        SETUP_MAX_AGGREGATION_STAGES,
-        std::vector<index>(matrix.numberOfRows(), std::numeric_limits<index>::max()));
-    std::vector<index> status(matrix.numberOfRows(), UNDECIDED);
-    std::vector<count> nc(SETUP_MAX_AGGREGATION_STAGES, matrix.numberOfRows());
-
-    double alpha = 1.0;
-    double maxCoarseningRatio = SETUP_COARSENING_WORK_GUARD / SETUP_CYCLE_INDEX;
-    count stage = 0;
-    count nC = matrix.numberOfRows();
-
-    // generate TVs
-    std::vector<Vector> tVs = generateTVs(matrix, tv, numTVVectors);
-
-    // compute strong adjacency matrix
-    Matrix Wstrong;
-    computeStrongAdjacencyMatrix(matrix, Wstrong);
-
-    // compute affinityMatrix
-    Matrix affinityMatrix;
-    computeAffinityMatrix(Wstrong, tVs, affinityMatrix);
-
-    // mark all locally high-degree nodes as seeds
-    addHighDegreeSeedNodes(matrix, status);
-
-    // aggregate all loose nodes
-    aggregateLooseNodes(Wstrong, status, nC);
-
-    nc[0] = nC;
-    while (stage < SETUP_MIN_AGGREGATION_STAGES
-           || (alpha >= maxCoarseningRatio && stage < SETUP_MAX_AGGREGATION_STAGES)) {
-        nC = stage > 0 ? nc[stage - 1] : nc[0];
-
-        // aggregation stage
-        aggregationStage(matrix, nC, Wstrong, affinityMatrix, tVs, status);
-
-        alpha = (double)nC / (double)matrix.numberOfRows();
-        alpha <= maxCoarseningRatio ? B[stage] = 1.0 - alpha : B[stage] = 1.0 + alpha;
-
-        S[stage] = status;
-        nc[stage] = nC;
-        stage++;
-    }
-
-    double min = B[0];
-    index bestAggregate = 0;
-    for (index i = 1; i < stage; ++i) {
-        if (B[i] < min) {
-            bestAggregate = i;
-            min = B[i];
-        }
-    }
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        if (S[bestAggregate][i] == UNDECIDED) { // undediced nodes become their own seeds
-            S[bestAggregate][i] = i;
-        }
-    }
-
-    std::vector<index> indexFine(matrix.numberOfRows(), 0);
-    index newIndex = 0;
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        if (S[bestAggregate][i] == i) {
-            indexFine[i] = newIndex++;
-        }
-    }
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        status[i] = indexFine[S[bestAggregate][i]];
-    }
-
-    assert(newIndex == nc[bestAggregate]);
-
-    // create interpolation matrix
-    std::vector<Triplet> pTriples(matrix.numberOfRows());
-    std::vector<Triplet> rTriples(matrix.numberOfRows());
-    std::vector<index> PColIndex(matrix.numberOfRows());
-    std::vector<std::vector<index>> PRowIndex(nc[bestAggregate]);
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        pTriples[i] = {i, status[i], 1};
-        rTriples[i] = {status[i], i, 1};
-        PColIndex[i] = status[i];
-        PRowIndex[status[i]].push_back(i);
-    }
-
-    Matrix P(matrix.numberOfRows(), nc[bestAggregate], pTriples);
-    Matrix R(nc[bestAggregate], matrix.numberOfRows(), rTriples);
-
-    // create coarsened laplacian
-    galerkinOperator(P, matrix, PColIndex, PRowIndex, matrix);
-
-    hierarchy.addAggregationLevel(matrix, P, R);
-}
-
-template <class Matrix>
-std::vector<Vector> MultiLevelSetup<Matrix>::generateTVs(const Matrix &matrix, Vector &tv,
-                                                         count numVectors) const {
-    std::vector<Vector> testVectors(numVectors, Vector(matrix.numberOfColumns()));
-
-    testVectors[0] = tv;
-
-    if (numVectors > 1) {
-        Vector b(matrix.numberOfColumns(), 0.0);
-#pragma omp parallel for
-        for (omp_index i = 1; i < static_cast<omp_index>(numVectors); ++i) {
-            for (count j = 0; j < matrix.numberOfColumns(); ++j) {
-                testVectors[i][j] = 2 * Aux::Random::probability() - 1;
-            }
-
-            testVectors[i] = smoother.relax(matrix, b, testVectors[i], SETUP_TV_SWEEPS);
-        }
-    }
-
-    return testVectors;
-}
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::addHighDegreeSeedNodes(const Matrix &matrix,
-                                                     std::vector<index> &status) const {
-    std::vector<count> deg(matrix.numberOfRows());
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        deg[i] = matrix.nnzInRow(i) - 1;
-    }
-
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        double num = 0.0;
-        double denom = 0.0;
-        matrix.forNonZeroElementsInRow(i, [&](index j, double value) {
-            if (i != j) {
-                num += std::abs(value) * (double)deg[j];
-            } else {
-                denom = std::abs(value);
-            }
-        });
-
-        // High degree node becomes seed
-        if ((double)deg[i] >= SETUP_AGGREGATION_DEGREE_THRESHOLD * (num / denom)) {
-            status[i] = i;
-        }
-    }
-}
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::aggregateLooseNodes(const Matrix &strongAdjMatrix,
-                                                  std::vector<index> &status, count &nc) const {
-    std::vector<index> looseNodes;
-    for (index i = 0; i < strongAdjMatrix.numberOfRows(); ++i) {
-        double max = std::numeric_limits<double>::min();
-        strongAdjMatrix.forNonZeroElementsInRow(i, [&](index /*j*/, double value) {
-            if (value > max)
-                max = value;
-        });
-
-        if (std::abs(max) < 1e-9 || max == std::numeric_limits<double>::min()) {
-            looseNodes.push_back(i);
-        }
-    }
-
-    if (!looseNodes.empty()) {
-        status[looseNodes[0]] = looseNodes[0]; // mark first as seed
-        for (index k = 1; k < looseNodes.size(); ++k) {
-            status[looseNodes[k]] = looseNodes[0]; // first loose nodes becomes seed
-        }
-
-        nc -= looseNodes.size() - 1;
-    }
-}
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::computeStrongAdjacencyMatrix(const Matrix &matrix,
-                                                           Matrix &strongAdjMatrix) const {
-    std::vector<double> maxNeighbor(matrix.numberOfRows(), std::numeric_limits<double>::min());
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        matrix.forNonZeroElementsInRow(i, [&](index j, double value) {
-            if (i != j && -value > maxNeighbor[i]) {
-                maxNeighbor[i] = -value;
-            }
-        });
-    }
-
-    std::vector<index> rowIdx(matrix.numberOfRows() + 1, 0);
-
-    matrix.parallelForNonZeroElementsInRowOrder([&](index i, index j, double value) {
-        if (i != j && std::abs(value) >= 0.1 * std::min(maxNeighbor[i], maxNeighbor[j])) {
-            ++rowIdx[i + 1];
-        }
-    });
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        rowIdx[i + 1] += rowIdx[i];
-    }
-
-    count nnz = rowIdx[matrix.numberOfRows()];
-    std::vector<Triplet> triplets(nnz);
-
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        index cIdx = rowIdx[i];
-        matrix.forNonZeroElementsInRow(i, [&](index j, double value) {
-            if (i != j && std::abs(value) >= 0.1 * std::min(maxNeighbor[i], maxNeighbor[j])) {
-                triplets[cIdx] = {static_cast<index>(i), j, -value};
-                ++cIdx;
-            }
-        });
-    }
-
-    strongAdjMatrix = Matrix(matrix.numberOfRows(), matrix.numberOfColumns(), triplets);
-}
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::computeAffinityMatrix(const Matrix &matrix,
-                                                    const std::vector<Vector> &tVs,
-                                                    Matrix &affinityMatrix) const {
-    assert(!tVs.empty());
-
-    std::vector<index> rowIdx(matrix.numberOfRows() + 1);
-    std::vector<Triplet> triplets(matrix.nnz());
-
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        rowIdx[i + 1] = matrix.nnzInRow(i);
-    }
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        rowIdx[i + 1] += rowIdx[i];
-    }
-
-    std::vector<double> normSquared(matrix.numberOfRows(), 0.0);
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        for (index k = 0; k < tVs.size(); ++k) {
-            normSquared[i] += tVs[k][i] * tVs[k][i];
-        }
-    }
-
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        double nir = 1.0 / normSquared[i];
-        index cIdx = rowIdx[i];
-        matrix.forNonZeroElementsInRow(i, [&](index j, double /*val*/) {
-            double ij = 0.0;
-            for (index k = 0; k < tVs.size(); ++k) {
-                ij += tVs[k][i] * tVs[k][j];
-            }
-
-            double value = (ij * ij) * nir / normSquared[j];
-            triplets[cIdx] = {static_cast<index>(i), j, value};
-            ++cIdx;
-        });
-    }
-
-    affinityMatrix = Matrix(matrix.numberOfRows(), matrix.numberOfColumns(), triplets);
-}
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::aggregationStage(const Matrix &matrix, count &nc,
-                                               const Matrix &strongAdjMatrix,
-                                               const Matrix &affinityMatrix,
-                                               std::vector<Vector> &tVs,
-                                               std::vector<index> &status) const {
-    std::vector<std::vector<index>> bins(10);
-    computeStrongNeighbors(affinityMatrix, status, bins);
-
-    std::vector<double> diag(matrix.numberOfRows(), 0.0);
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        diag[i] = matrix(i, i);
-    }
-    // Iterate over undecided nodes with strong neighbors in decreasing order of strongest neighbor
-    for (index k = bins.size(); k-- > 0;) {
-        for (index i : bins[k]) {
-            if (status[i] == UNDECIDED) { // node is still undecided
-                index s = 0;
-                if (findBestSeedEnergyCorrected(strongAdjMatrix, affinityMatrix, diag, tVs, status,
-                                                i, s)) {
-                    status[s] = s; // s becomes seed
-                    status[i] = s; // i's seed is s
-                    nc--;
-
-                    for (index j = 0; j < tVs.size(); ++j) { // update test vectors
-                        tVs[j][i] = tVs[j][s];
-                    }
-                }
-            }
-        }
-
-        if (nc <= matrix.numberOfRows() * SETUP_COARSENING_WORK_GUARD / SETUP_CYCLE_INDEX) {
-            break;
-        }
-    } // iterate over bins
-}
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::computeStrongNeighbors(const Matrix &affinityMatrix,
-                                                     const std::vector<index> &status,
-                                                     std::vector<std::vector<index>> &bins) const {
-    std::vector<bool> undecided(affinityMatrix.numberOfRows(), false);
-    std::vector<double> maxNeighbor(affinityMatrix.numberOfRows(),
-                                    std::numeric_limits<double>::min());
-    double overallMax = 0.0;
-    double overallMin = std::numeric_limits<double>::max();
-
-    affinityMatrix.parallelForNonZeroElementsInRowOrder(
-        [&](index i, index j,
-            double value) { // determine the highest affinity neighbor of each node
-            if (status[i] == UNDECIDED && (status[j] == UNDECIDED || status[j] == j)) {
-                // 'i' is UNDECIDED and its neighbor 'j' is also UNDECIDED or SEED
-                if (value > maxNeighbor[i]) {
-                    maxNeighbor[i] = value;
-                }
-                undecided[i] = true;
-            }
-        });
-
-    for (index i = 0; i < affinityMatrix.numberOfRows(); ++i) {
-        if (maxNeighbor[i] > overallMax) {
-            overallMax = maxNeighbor[i];
-        }
-        if (maxNeighbor[i] < overallMin) {
-            overallMin = maxNeighbor[i];
-        }
-    }
-
-    double h = std::fabs(overallMax - overallMin) < 1e-15
-                   ? 1.0
-                   : (double)bins.size() / (overallMax - overallMin);
-    for (index i = 0; i < affinityMatrix.numberOfRows(); ++i) {
-        if (undecided[i]) { // undecided nodes with strong neighbors
-            index binIndex = (index)std::floor(h * (maxNeighbor[i] - overallMin));
-            if (binIndex == bins.size()) { // last interval is closed on the right
-                binIndex--;
-            }
-
-            assert(binIndex < bins.size());
-            bins[binIndex].push_back(i);
-        }
-    }
-}
-
-template <class Matrix>
-bool MultiLevelSetup<Matrix>::findBestSeedEnergyCorrected(const Matrix &strongAdjMatrix,
-                                                          const Matrix &affinityMatrix,
-                                                          const std::vector<double> &diag,
-                                                          const std::vector<Vector> &tVs,
-                                                          const std::vector<index> &status,
-                                                          const index u, index &s) const {
-    bool foundSeed = false;
-    std::vector<double> r(tVs.size(), 0.0);
-    std::vector<double> q(tVs.size(), 0.0);
-    std::vector<double> E(tVs.size(), 0.0);
-
-    double d = diag[u];
-    double d2 = 0.5 * diag[u];
-    for (index k = 0; k < tVs.size(); ++k) {
-        double rr = 0.0;
-        double qq = 0.0;
-        strongAdjMatrix.forNonZeroElementsInRow(u, [&](index v, double value) {
-            rr += value * tVs[k][v];
-            qq += value * 0.5 * tVs[k][v] * tVs[k][v];
-        });
-
-        r[k] = rr;
-        q[k] = qq;
-        double y = rr / d;
-        E[k] = (d2 * y - rr) * y + qq;
-    }
-
-    double maxNeighbor = -1.0;
-    affinityMatrix.forNonZeroElementsInRow(u, [&](index v, double value) {
-        if (status[v] == UNDECIDED || status[v] == v) {
-            double maxMu = -1.0;
-            bool smallRatio = true;
-            for (index k = 0; k < tVs.size(); ++k) {
-                double xv = tVs[k][v];
-                double Ec = (d2 * xv - r[k]) * xv + q[k];
-                double mu = Ec / (E[k] + 1e-15);
-
-                if (mu > maxMu) {
-                    maxMu = mu;
-                }
-                if (maxMu > 2.5) {
-                    smallRatio = false;
-                    break;
-                }
-            }
-
-            if (smallRatio && value > maxNeighbor) {
-                maxNeighbor = value;
-                s = v;
-                foundSeed = true;
-            }
-        }
-    });
-
-    return foundSeed;
-}
-
-template <class Matrix>
-bool MultiLevelSetup<Matrix>::isRelaxationFast(const Matrix &A, index lvlIndex, Vector &tv) const {
-    count nu = SETUP_RELAX_ACF_MIN_SWEEPS + 2 * (lvlIndex - 1);
-    count tvNu = SETUP_TV_SWEEPS;
-    count initial = 3;
-
-    // create testVector in [-1,1]
-    tv = Vector(A.numberOfRows());
-    for (index i = 0; i < tv.getDimension(); ++i) {
-        tv[i] = 2.0 * Aux::Random::probability() - 1.0;
-    }
-
-    Vector b(A.numberOfRows(), 0.0);
-    Vector x = tv;
-    x = smoother.relax(A, b, x, initial);
-    tv = smoother.relax(A, b, x, tvNu - initial);
-    Vector y = smoother.relax(A, b, tv, nu - tvNu);
-    double relaxAcf = std::pow((y - y.mean()).length() / (x - x.mean()).length(),
-                               (double)1.0 / (double)(nu - initial));
-    return relaxAcf <= SETUP_MAX_COARSE_RELAX_ACF || !canCoarsen(A);
-}
-
-template <class Matrix>
-void MultiLevelSetup<Matrix>::galerkinOperator(const Matrix &P, const Matrix &A,
-                                               const std::vector<index> &PColIndex,
-                                               const std::vector<std::vector<index>> &PRowIndex,
-                                               Matrix &B) const {
-    std::vector<Triplet> triplets;
-    SparseAccumulator spa(P.numberOfColumns());
-    for (index i = 0; i < P.numberOfColumns(); ++i) {
-        for (index k : PRowIndex[i]) {
-            double Pki = P(k, i);
-            A.forNonZeroElementsInRow(k, [&](index l, double value) {
-                index j = PColIndex[l];
-                spa.scatter(Pki * value * P(l, j), j);
-            });
-        }
-
-        spa.gather([&](index i, index j, double value) { triplets.push_back({i, j, value}); });
-
-        spa.increaseRow();
-    }
-
-    B = Matrix(P.numberOfColumns(), P.numberOfColumns(), triplets);
-}
-
-template <>
-inline void MultiLevelSetup<CSRMatrix>::setup(CSRMatrix matrix,
-                                              LevelHierarchy<CSRMatrix> &hierarchy) const {
-    matrix.sort();
-    setupForMatrix(matrix, hierarchy);
-}
-
-template <>
-inline void
-MultiLevelSetup<CSRMatrix>::computeStrongAdjacencyMatrix(const CSRMatrix &matrix,
-                                                         CSRMatrix &strongAdjMatrix) const {
-    std::vector<double> maxNeighbor(matrix.numberOfRows(), std::numeric_limits<double>::min());
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        matrix.forNonZeroElementsInRow(i, [&](index j, double value) {
-            if (i != j && -value > maxNeighbor[i]) {
-                maxNeighbor[i] = -value;
-            }
-        });
-    }
-
-    std::vector<index> rowIdx(matrix.numberOfRows() + 1, 0);
-    matrix.parallelForNonZeroElementsInRowOrder([&](index i, index j, double value) {
-        if (i != j && std::abs(value) >= 0.1 * std::min(maxNeighbor[i], maxNeighbor[j])) {
-            ++rowIdx[i + 1];
-        }
-    });
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        rowIdx[i + 1] += rowIdx[i];
-    }
-
-    count nnz = rowIdx[matrix.numberOfRows()];
-    std::vector<index> columnIdx(nnz);
-    std::vector<double> nonZeros(nnz);
-
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        index cIdx = rowIdx[i];
-        matrix.forNonZeroElementsInRow(i, [&](index j, double value) {
-            if (i != j && std::abs(value) >= 0.1 * std::min(maxNeighbor[i], maxNeighbor[j])) {
-                columnIdx[cIdx] = j;
-                nonZeros[cIdx] = -value;
-                ++cIdx;
-            }
-        });
-    }
-
-    strongAdjMatrix = CSRMatrix(matrix.numberOfRows(), matrix.numberOfColumns(), rowIdx, columnIdx,
-                                nonZeros, 0.0, matrix.sorted());
-}
-
-template <>
-inline void MultiLevelSetup<CSRMatrix>::computeAffinityMatrix(const CSRMatrix &matrix,
-                                                              const std::vector<Vector> &tVs,
-                                                              CSRMatrix &affinityMatrix) const {
-    assert(!tVs.empty());
-
-    std::vector<index> rowIdx(matrix.numberOfRows() + 1);
-    std::vector<index> columnIdx(matrix.nnz());
-    std::vector<double> nonZeros(matrix.nnz());
-
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        rowIdx[i + 1] = matrix.nnzInRow(i);
-    }
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        rowIdx[i + 1] += rowIdx[i];
-    }
-
-    std::vector<double> normSquared(matrix.numberOfRows(), 0.0);
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        for (index k = 0; k < tVs.size(); ++k) {
-            normSquared[i] += tVs[k][i] * tVs[k][i];
-        }
-    }
-
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(matrix.numberOfRows()); ++i) {
-        double nir = 1.0 / normSquared[i];
-        index cIdx = rowIdx[i];
-        matrix.forNonZeroElementsInRow(i, [&](index j, double /*val*/) {
-            double ij = 0.0;
-            for (index k = 0; k < tVs.size(); ++k) {
-                ij += tVs[k][i] * tVs[k][j];
-            }
-
-            double value = (ij * ij) * nir / normSquared[j];
-            columnIdx[cIdx] = j;
-            nonZeros[cIdx] = value;
-            ++cIdx;
-        });
-    }
-
-    affinityMatrix = CSRMatrix(matrix.numberOfRows(), matrix.numberOfColumns(), rowIdx, columnIdx,
-                               nonZeros, 0.0, matrix.sorted());
-}
-
-template <>
-inline void MultiLevelSetup<CSRMatrix>::galerkinOperator(
-    const CSRMatrix &P, const CSRMatrix &A, const std::vector<index> &PColIndex,
-    const std::vector<std::vector<index>> &PRowIndex, CSRMatrix &B) const {
-    std::vector<Triplet> triplets;
-    SparseAccumulator spa(P.numberOfColumns());
-    for (index i = 0; i < P.numberOfColumns(); ++i) {
-        for (index k : PRowIndex[i]) {
-            double Pki = P(k, i);
-            A.forNonZeroElementsInRow(k, [&](index l, double value) {
-                index j = PColIndex[l];
-                spa.scatter(Pki * value * P(l, j), j);
-            });
-        }
-
-        spa.gather([&](index i, index j, double value) { triplets.push_back({i, j, value}); });
-
-        spa.increaseRow();
-    }
-
-    B = CSRMatrix(P.numberOfColumns(), P.numberOfColumns(), triplets, 0.0, true);
-}
-
-template <>
-inline void MultiLevelSetup<CSRMatrix>::eliminationOperators(const CSRMatrix &matrix,
-                                                             const std::vector<index> &fSet,
-                                                             const std::vector<index> &coarseIndex,
-                                                             CSRMatrix &P, Vector &q) const {
-    std::vector<Triplet> triples;
-    q = Vector(fSet.size());
-    for (index k = 0; k < fSet.size(); ++k) { // Afc
-        matrix.forNonZeroElementsInRow(fSet[k], [&](index j, edgeweight w) {
-            if (fSet[k] == j) {
-                q[k] = 1.0 / w;
-            } else {
-                triples.push_back({k, coarseIndex[j], w});
-            }
-        });
-    }
-
-    for (index i = 0; i < triples.size(); ++i) { // * -Aff^-1
-        triples[i].value *= -q[triples[i].row];
-    }
-
-    P = CSRMatrix(fSet.size(), coarseIndex.size() - fSet.size(), triples, 0.0, matrix.sorted());
-}
-
-template <>
-inline void MultiLevelSetup<CSRMatrix>::coarseningAggregation(CSRMatrix &matrix,
-                                                              LevelHierarchy<CSRMatrix> &hierarchy,
-                                                              Vector &tv,
-                                                              count numTVVectors) const {
-    Vector B(SETUP_MAX_AGGREGATION_STAGES, std::numeric_limits<double>::max());
-    std::vector<std::vector<index>> S(
-        SETUP_MAX_AGGREGATION_STAGES,
-        std::vector<index>(matrix.numberOfRows(), std::numeric_limits<index>::max()));
-    std::vector<index> status(matrix.numberOfRows(), UNDECIDED);
-    std::vector<count> nc(SETUP_MAX_AGGREGATION_STAGES, matrix.numberOfRows());
-
-    double alpha = 1.0;
-    double maxCoarseningRatio = SETUP_COARSENING_WORK_GUARD / SETUP_CYCLE_INDEX;
-    count stage = 0;
-    count nC = matrix.numberOfRows();
-
-    // generate TVs
-    std::vector<Vector> tVs = generateTVs(matrix, tv, numTVVectors);
-
-    // compute strong adjacency matrix
-    CSRMatrix Wstrong;
-    computeStrongAdjacencyMatrix(matrix, Wstrong);
-
-    // compute affinityMatrix
-    CSRMatrix affinityMatrix;
-    computeAffinityMatrix(Wstrong, tVs, affinityMatrix);
-
-    // mark all locally high-degree nodes as seeds
-    addHighDegreeSeedNodes(matrix, status);
-
-    // aggregate all loose nodes
-    aggregateLooseNodes(Wstrong, status, nC);
-
-    nc[0] = nC;
-    while (stage < SETUP_MIN_AGGREGATION_STAGES
-           || (alpha >= maxCoarseningRatio && stage < SETUP_MAX_AGGREGATION_STAGES)) {
-        nC = stage > 0 ? nc[stage - 1] : nc[0];
-
-        // aggregation stage
-        aggregationStage(matrix, nC, Wstrong, affinityMatrix, tVs, status);
-
-        alpha = (double)nC / (double)matrix.numberOfRows();
-        alpha <= maxCoarseningRatio ? B[stage] = 1.0 - alpha : B[stage] = 1.0 + alpha;
-
-        S[stage] = status;
-        nc[stage] = nC;
-        stage++;
-    }
-
-    double min = B[0];
-    index bestAggregate = 0;
-    for (index i = 1; i < stage; ++i) {
-        if (B[i] < min) {
-            bestAggregate = i;
-            min = B[i];
-        }
-    }
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        if (S[bestAggregate][i] == UNDECIDED) { // undediced nodes become their own seeds
-            S[bestAggregate][i] = i;
-        }
-    }
-
-    std::vector<index> indexFine(matrix.numberOfRows(), 0);
-    index newIndex = 0;
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        if (S[bestAggregate][i] == i) {
-            indexFine[i] = newIndex++;
-        }
-    }
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        status[i] = indexFine[S[bestAggregate][i]];
-    }
-
-    assert(newIndex == nc[bestAggregate]);
-
-    // create interpolation matrix
-    std::vector<Triplet> pTriples(matrix.numberOfRows());
-    std::vector<Triplet> rTriples(matrix.numberOfRows());
-    std::vector<index> PColIndex(matrix.numberOfRows());
-    std::vector<std::vector<index>> PRowIndex(nc[bestAggregate]);
-
-    for (index i = 0; i < matrix.numberOfRows(); ++i) {
-        pTriples[i] = {i, status[i], 1};
-        rTriples[i] = {status[i], i, 1};
-        PColIndex[i] = status[i];
-        PRowIndex[status[i]].push_back(i);
-    }
-
-    CSRMatrix P(matrix.numberOfRows(), nc[bestAggregate], pTriples, 0.0, matrix.sorted());
-    CSRMatrix R(nc[bestAggregate], matrix.numberOfRows(), rTriples, 0.0, matrix.sorted());
-
-    // create coarsened laplacian
-    galerkinOperator(P, matrix, PColIndex, PRowIndex, matrix);
-
-    hierarchy.addAggregationLevel(matrix, P, R);
-}
-
-extern template class MultiLevelSetup<CSRMatrix>;
-extern template class MultiLevelSetup<DenseMatrix>;
-extern template class MultiLevelSetup<DynamicMatrix>;
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_NUMERICS_LAMG_MULTI_LEVEL_SETUP_HPP_