@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,133 @@
+/*
+ * LevelElimination.hpp
+ *
+ *  Created on: 10.01.2015
+ *      Author: Michael
+ */
+
+#ifndef NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_ELIMINATION_HPP_
+#define NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_ELIMINATION_HPP_
+
+#include <networkit/numerics/LAMG/Level/EliminationStage.hpp>
+#include <networkit/numerics/LAMG/Level/Level.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup numerics
+ */
+template <class Matrix>
+class LevelElimination : public Level<Matrix> {
+private:
+    std::vector<EliminationStage<Matrix>> coarseningStages;
+    std::vector<index> cIndexFine;
+
+    void subVectorExtract(Vector &subVector, const Vector &vector,
+                          const std::vector<index> &elements) const;
+
+public:
+    LevelElimination(const Matrix &A,
+                     const std::vector<EliminationStage<Matrix>> &coarseningStages);
+
+    void coarseType(const Vector &xf, Vector &xc) const override;
+    void restrict(const Vector &bf, Vector &bc, std::vector<Vector> &bStages) const override;
+    void interpolate(const Vector &xc, Vector &xf,
+                     const std::vector<Vector> &bStages) const override;
+};
+
+template <class Matrix>
+LevelElimination<Matrix>::LevelElimination(
+    const Matrix &A, const std::vector<EliminationStage<Matrix>> &coarseningStages)
+    : Level<Matrix>(LevelType::ELIMINATION, A), coarseningStages(coarseningStages) {
+    cIndexFine = std::vector<index>(this->A.numberOfRows());
+#pragma omp parallel for
+    for (omp_index i = 0; i < static_cast<omp_index>(cIndexFine.size()); ++i) {
+        cIndexFine[i] = i;
+    }
+
+    for (index k = coarseningStages.size(); k-- > 0;) {
+        for (index i = 0; i < cIndexFine.size(); ++i) {
+            assert(cIndexFine[i] < coarseningStages[k].getCSet().size());
+            cIndexFine[i] = coarseningStages[k].getCSet()[cIndexFine[i]];
+        }
+    }
+}
+
+template <class Matrix>
+void LevelElimination<Matrix>::coarseType(const Vector &xf, Vector &xc) const {
+    xc = Vector(this->A.numberOfRows());
+#pragma omp parallel for
+    for (omp_index i = 0; i < static_cast<omp_index>(xc.getDimension()); ++i) {
+        xc[i] = xf[cIndexFine[i]];
+    }
+}
+
+template <class Matrix>
+void LevelElimination<Matrix>::restrict(const Vector &bf, Vector &bc,
+                                        std::vector<Vector> &bStages) const {
+    bStages.resize(coarseningStages.size() + 1);
+    bStages[0] = bf;
+    bc = bf;
+    index curStage = 0;
+    for (const EliminationStage<Matrix> &s : coarseningStages) {
+        // Vector bOld = bStages[curStage];
+        Vector bCSet;
+        subVectorExtract(bCSet, bc, s.getCSet());
+
+        Vector bFSet;
+        subVectorExtract(bFSet, bc, s.getFSet());
+        bc = bCSet + s.getR() * bFSet;
+        bStages[curStage + 1] = bc; // b = b.c + s.P^T * b.f
+
+        curStage++;
+    }
+}
+
+template <class Matrix>
+void LevelElimination<Matrix>::interpolate(const Vector &xc, Vector &xf,
+                                           const std::vector<Vector> &bStages) const {
+    Vector currX = xc;
+    for (index k = coarseningStages.size(); k-- > 0;) {
+        const EliminationStage<Matrix> &s = coarseningStages[k];
+        xf = Vector(s.getN());
+        Vector bFSet;
+        subVectorExtract(bFSet, bStages[k], s.getFSet());
+
+        Vector bq(bFSet.getDimension());
+        const Vector &q = s.getQ();
+#pragma omp parallel for
+        for (omp_index i = 0; i < static_cast<omp_index>(bq.getDimension());
+             ++i) { // bq = s.q .* b.f
+            bq[i] = q[i] * bFSet[i];
+        }
+        Vector xFSet = s.getP() * currX + bq;
+
+        const std::vector<index> &fSet = s.getFSet();
+#pragma omp parallel for
+        for (omp_index i = 0; i < static_cast<omp_index>(xFSet.getDimension()); ++i) {
+            xf[fSet[i]] = xFSet[i];
+        }
+
+        const std::vector<index> &cSet = s.getCSet();
+#pragma omp parallel for
+        for (omp_index i = 0; i < static_cast<omp_index>(currX.getDimension()); ++i) {
+            xf[cSet[i]] = currX[i];
+        }
+
+        currX = xf;
+    }
+}
+
+template <class Matrix>
+void LevelElimination<Matrix>::subVectorExtract(Vector &subVector, const Vector &vector,
+                                                const std::vector<index> &elements) const {
+    subVector = Vector(elements.size());
+#pragma omp parallel for
+    for (omp_index i = 0; i < static_cast<omp_index>(elements.size()); ++i) {
+        subVector[i] = vector[elements[i]];
+    }
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_ELIMINATION_HPP_

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

@@ -0,0 +1,28 @@
+/*
+ * LevelFinest.hpp
+ *
+ *  Created on: 10.01.2015
+ *      Author: Michael
+ */
+
+#ifndef NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_FINEST_HPP_
+#define NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_FINEST_HPP_
+
+#include <networkit/numerics/LAMG/Level/Level.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup numerics
+ */
+template <class Matrix>
+class LevelFinest : public Level<Matrix> {
+public:
+    LevelFinest() : Level<Matrix>(LevelType::FINEST) {}
+    LevelFinest(const Matrix &A) : Level<Matrix>(LevelType::FINEST, A) {}
+    ~LevelFinest() override = default;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_NUMERICS_LAMG_LEVEL_LEVEL_FINEST_HPP_

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

@@ -0,0 +1,165 @@
+/*
+ * LevelHierarchy.hpp
+ *
+ *  Created on: 10.01.2015
+ *      Author: Michael
+ */
+
+#ifndef NETWORKIT_NUMERICS_LAMG_LEVEL_HIERARCHY_HPP_
+#define NETWORKIT_NUMERICS_LAMG_LEVEL_HIERARCHY_HPP_
+
+#include <networkit/algebraic/CSRMatrix.hpp>
+#include <networkit/algebraic/DenseMatrix.hpp>
+#include <networkit/algebraic/DynamicMatrix.hpp>
+#include <networkit/numerics/LAMG/LAMGSettings.hpp>
+#include <networkit/numerics/LAMG/Level/Level.hpp>
+#include <networkit/numerics/LAMG/Level/LevelAggregation.hpp>
+#include <networkit/numerics/LAMG/Level/LevelElimination.hpp>
+#include <networkit/numerics/LAMG/Level/LevelFinest.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup numerics
+ */
+template <class Matrix>
+class LevelHierarchy {
+private:
+    std::vector<LevelType> levelType;
+    std::vector<index> levelIndex;
+    std::vector<LevelElimination<Matrix>> eliminationLevels;
+    std::vector<LevelAggregation<Matrix>> aggregationLevels;
+    LevelFinest<Matrix> finestLevel;
+    DenseMatrix coarseLUMatrix;
+
+    void createCoarseMatrix();
+
+public:
+    LevelHierarchy() = default;
+
+    void addFinestLevel(const Matrix &A);
+    void addEliminationLevel(const Matrix &A,
+                             const std::vector<EliminationStage<Matrix>> &coarseningStages);
+    void addAggregationLevel(const Matrix &A, const Matrix &P, const Matrix &R);
+    void setLastAsCoarsest();
+    inline const DenseMatrix &getCoarseMatrix() const { return coarseLUMatrix; }
+
+    inline count size() const {
+        return levelType.size() + 1; // elimination + aggregation levels + finestLevel
+    }
+
+    LevelType getType(index levelIdx) const;
+    Level<Matrix> &at(index levelIdx);
+    const Level<Matrix> &at(index levelIdx) const;
+    double cycleIndex(index levelIdx) const;
+};
+
+template <class Matrix>
+void LevelHierarchy<Matrix>::addFinestLevel(const Matrix &A) {
+    finestLevel = LevelFinest<Matrix>(A);
+}
+
+template <class Matrix>
+void LevelHierarchy<Matrix>::addEliminationLevel(
+    const Matrix &A, const std::vector<EliminationStage<Matrix>> &coarseningStages) {
+    levelType.push_back(ELIMINATION);
+    levelIndex.push_back(eliminationLevels.size());
+    eliminationLevels.push_back(LevelElimination<Matrix>(A, coarseningStages));
+}
+
+template <class Matrix>
+void LevelHierarchy<Matrix>::addAggregationLevel(const Matrix &A, const Matrix &P,
+                                                 const Matrix &R) {
+    levelType.push_back(AGGREGATION);
+    levelIndex.push_back(aggregationLevels.size());
+    aggregationLevels.push_back(LevelAggregation<Matrix>(A, P, R));
+}
+
+template <class Matrix>
+void LevelHierarchy<Matrix>::setLastAsCoarsest() {
+    const Matrix &A = this->at(size() - 1).getLaplacian();
+    count n = A.numberOfRows() + 1;
+    std::vector<double> entries(n * n, 0.0);
+    A.parallelForNonZeroElementsInRowOrder(
+        [&](index i, index j, double value) { entries[i * n + j] = value; });
+
+    for (index i = 0; i < n - 1; ++i) {
+        entries[i * n + n - 1] = 1;
+        entries[(n - 1) * n + i] = 1;
+    }
+
+    coarseLUMatrix = DenseMatrix(n, n, entries);
+    DenseMatrix::LUDecomposition(coarseLUMatrix);
+}
+
+template <class Matrix>
+LevelType LevelHierarchy<Matrix>::getType(index levelIdx) const {
+    assert(levelIdx < this->size());
+
+    if (levelIdx == 0) {
+        return FINEST;
+    } else {
+        return levelType[levelIdx - 1];
+    }
+}
+
+template <class Matrix>
+Level<Matrix> &LevelHierarchy<Matrix>::at(index levelIdx) {
+    assert(levelIdx < this->size());
+
+    if (levelIdx == 0) { // finest level
+        return finestLevel;
+    } else {
+        levelIdx--;
+    }
+
+    if (levelType[levelIdx] == ELIMINATION) {
+        return eliminationLevels[levelIndex[levelIdx]];
+    } else {
+        return aggregationLevels[levelIndex[levelIdx]];
+    }
+}
+
+template <class Matrix>
+const Level<Matrix> &LevelHierarchy<Matrix>::at(index levelIdx) const {
+    assert(levelIdx < this->size());
+
+    if (levelIdx == 0) { // finest level
+        return finestLevel;
+    } else {
+        levelIdx--;
+    }
+
+    if (levelType[levelIdx] == ELIMINATION) {
+        return eliminationLevels[levelIndex[levelIdx]];
+    } else {
+        return aggregationLevels[levelIndex[levelIdx]];
+    }
+}
+
+template <class Matrix>
+double LevelHierarchy<Matrix>::cycleIndex(index levelIdx) const {
+    double gamma = 1.0;
+    if (getType(levelIdx + 1) != ELIMINATION) {
+        const double finestNumEdges = finestLevel.getLaplacian().nnz();
+        const double numFineEdges = this->at(levelIdx).getLaplacian().nnz();
+
+        if (numFineEdges > 0.1 * finestNumEdges) {
+            gamma = SETUP_CYCLE_INDEX;
+        } else {
+            double numCoarseEdges = this->at(levelIdx + 1).getLaplacian().nnz();
+            gamma = std::max(
+                1.0, std::min(1.5, SETUP_COARSENING_WORK_GUARD / (numCoarseEdges / numFineEdges)));
+        }
+    }
+
+    return gamma;
+}
+
+extern template class LevelHierarchy<CSRMatrix>;
+extern template class LevelHierarchy<DenseMatrix>;
+extern template class LevelHierarchy<DynamicMatrix>;
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_NUMERICS_LAMG_LEVEL_HIERARCHY_HPP_