@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,316 @@
+/*
+ * SolverLamg.hpp
+ *
+ *  Created on: 12.01.2015
+ *      Author: Michael
+ */
+
+#ifndef NETWORKIT_NUMERICS_LAMG_SOLVER_LAMG_HPP_
+#define NETWORKIT_NUMERICS_LAMG_SOLVER_LAMG_HPP_
+
+#include <cmath>
+#include <vector>
+
+#include <networkit/algebraic/DenseMatrix.hpp>
+#include <networkit/auxiliary/Timer.hpp>
+#include <networkit/numerics/LAMG/LevelHierarchy.hpp>
+#include <networkit/numerics/Smoother.hpp>
+
+namespace NetworKit {
+
+/**
+ * Status parameters of the solver.
+ */
+struct LAMGSolverStatus {
+    // in
+    count maxIters = std::numeric_limits<count>::max(); // maximum number of iterations
+    // Maximum time in milliseconds spent to solve the system
+    count maxConvergenceTime = std::numeric_limits<count>::max();
+    // Desired reduction of the initial residual (finalResidual <= desiredResReduction *
+    // initialResidual)
+    double desiredResidualReduction = 1e-8;
+    count numPreSmoothIters = 1;  // number of pre smoothing iterations
+    count numPostSmoothIters = 2; // number of post smoothing iterations
+
+    // out
+    count numIters = 0; // number of iterations needed during solve phase
+    double residual = std::numeric_limits<double>::infinity(); // absolute final residual
+    bool converged = false;                                    // flag of conversion status
+    std::vector<double> residualHistory;                       // history of absolute residuals
+};
+
+/**
+ * @ingroup numerics
+ * Implements the solve phase of LAMG (Lean Algebraic Multigrid by Livne et al.).
+ */
+template <class Matrix>
+class SolverLamg {
+private:
+    const LevelHierarchy<Matrix> &hierarchy;
+    const Smoother<Matrix> &smoother;
+
+    // data structures for iterate recombination
+    std::vector<std::vector<Vector>> history;
+    std::vector<std::vector<Vector>> rHistory;
+    std::vector<index> latestIterate;
+    std::vector<count> numActiveIterates;
+
+    // bStages for Elimination Levels
+    std::vector<std::vector<Vector>> bStages;
+
+    void solveCycle(Vector &x, const Vector &b, int finest, LAMGSolverStatus &status);
+    void cycle(Vector &x, const Vector &b, int finest, int coarsest, std::vector<count> &numVisits,
+               std::vector<Vector> &X, std::vector<Vector> &B, const LAMGSolverStatus &status);
+    void saveIterate(index level, const Vector &x, const Vector &r);
+    void clearHistory(index level);
+    void minRes(index level, Vector &x, const Vector &r) const;
+
+public:
+    /**
+     * Constructs a new solver instance for the specified @a hierarchy. The @a smoother will be used
+     * for relaxing and solving the coarser solutions.
+     * @param hierarchy Reference to the LevelHierarchy constructed by MultiLevelSetup.
+     * @param smoother Reference to a smoother.
+     */
+    SolverLamg(const LevelHierarchy<Matrix> &hierarchy, const Smoother<Matrix> &smoother)
+        : hierarchy(hierarchy), smoother(smoother),
+          bStages(hierarchy.size(), std::vector<Vector>()) {}
+
+    SolverLamg(const SolverLamg<Matrix> &other) = default;
+
+    SolverLamg(SolverLamg<Matrix> &&other) noexcept = default;
+
+    virtual ~SolverLamg() = default;
+
+    SolverLamg &operator=(SolverLamg<Matrix> &&other) noexcept = default;
+
+    SolverLamg &operator=(const SolverLamg<Matrix> &other) = default;
+
+    /**
+     * Solves the system A*x = b for the given initial @a x and right-hand side @a b. More
+     * parameters can be specified in @a status and additional output is also stored in @a status.
+     * After the solver finished, the approximate solution is stored in @a x.
+     * @param x[out] Reference to the initial guess to the solution and the approximation after the
+     * solver finished.
+     * @param b The right-hand side vector.
+     * @param status Reference to an LAMGSolverStatus.
+     */
+    void solve(Vector &x, const Vector &b, LAMGSolverStatus &status);
+};
+
+template <class Matrix>
+void SolverLamg<Matrix>::solve(Vector &x, const Vector &b, LAMGSolverStatus &status) {
+    bStages = std::vector<std::vector<Vector>>(hierarchy.size(), std::vector<Vector>());
+    if (hierarchy.size() >= 2) {
+        Vector bc = b;
+        Vector xc = x;
+        int finest = 0;
+
+        if (hierarchy.getType(1) == ELIMINATION) {
+            hierarchy.at(1).restrict(b, bc, bStages[1]);
+            if (hierarchy.at(1).getLaplacian().numberOfRows() == 1) {
+                x = 0.0;
+                return;
+            } else {
+                hierarchy.at(1).coarseType(x, xc);
+                finest = 1;
+            }
+        }
+        solveCycle(xc, bc, finest, status);
+
+        // interpolate from finest == ELIMINATION level back to actual finest level
+        if (finest == 1) {
+            hierarchy.at(1).interpolate(xc, x, bStages[1]);
+        } else {
+            x = xc;
+        }
+    } else {
+        solveCycle(x, b, 0, status);
+    }
+
+    double residual = (b - hierarchy.at(0).getLaplacian() * x).length();
+    status.residual = residual;
+}
+
+template <class Matrix>
+void SolverLamg<Matrix>::solveCycle(Vector &x, const Vector &b, const int finest,
+                                    LAMGSolverStatus &status) {
+    Aux::Timer timer;
+    timer.start();
+
+    // data structures for iterate recombination
+    history = std::vector<std::vector<Vector>>(hierarchy.size());
+    rHistory = std::vector<std::vector<Vector>>(hierarchy.size());
+    latestIterate = std::vector<index>(hierarchy.size(), 0);
+    numActiveIterates = std::vector<count>(hierarchy.size(), 0);
+    int coarsest = hierarchy.size() - 1;
+    std::vector<count> numVisits(coarsest);
+    std::vector<Vector> X(hierarchy.size());
+    std::vector<Vector> B(hierarchy.size());
+
+    for (index i = 0; i < hierarchy.size(); ++i) {
+        history[i] =
+            std::vector<Vector>(MAX_COMBINED_ITERATES, Vector(hierarchy.at(i).getNumberOfNodes()));
+        rHistory[i] =
+            std::vector<Vector>(MAX_COMBINED_ITERATES, Vector(hierarchy.at(i).getNumberOfNodes()));
+    }
+
+    Vector r = b - hierarchy.at(finest).getLaplacian() * x;
+    double residual = r.length();
+    double finalResidual = residual * status.desiredResidualReduction;
+    double bestResidual = std::numeric_limits<double>::max();
+
+    count iterations = 0;
+    status.residualHistory.emplace_back(residual);
+    count noResReduction = 0;
+    while (residual > finalResidual && noResReduction < 5 && iterations < status.maxIters
+           && timer.elapsedMilliseconds() <= status.maxConvergenceTime) {
+        cycle(x, b, finest, coarsest, numVisits, X, B, status);
+        r = b - hierarchy.at(finest).getLaplacian() * x;
+        residual = r.length();
+        status.residualHistory.emplace_back(residual);
+        if (residual < bestResidual) {
+            noResReduction = 0;
+            bestResidual = residual;
+        } else {
+            ++noResReduction;
+        }
+        iterations++;
+    }
+
+    timer.stop();
+
+    status.numIters = iterations;
+    status.residual = r.length();
+    status.converged = r.length() <= finalResidual;
+}
+
+template <class Matrix>
+void SolverLamg<Matrix>::cycle(Vector &x, const Vector &b, const int finest, const int coarsest,
+                               std::vector<count> &numVisits, std::vector<Vector> &X,
+                               std::vector<Vector> &B, const LAMGSolverStatus &status) {
+    std::fill(numVisits.begin(), numVisits.end(), 0);
+    X[finest] = x;
+    B[finest] = b;
+
+    int currLvl = finest;
+    int nextLvl = finest;
+    double maxVisits = 0.0;
+
+    saveIterate(currLvl, X[currLvl],
+                B[currLvl] - hierarchy.at(currLvl).getLaplacian() * X[currLvl]);
+    while (true) {
+        if (currLvl == coarsest) {
+            nextLvl = currLvl - 1;
+            if (currLvl == finest) { // finest level
+                X[currLvl] = smoother.relax(hierarchy.at(currLvl).getLaplacian(), B[currLvl],
+                                            X[currLvl], status.numPreSmoothIters);
+            } else {
+                Vector bCoarse(B[currLvl].getDimension() + 1, 0.0);
+                for (index i = 0; i < B[currLvl].getDimension(); ++i) {
+                    bCoarse[i] = B[currLvl][i];
+                }
+
+                Vector xCoarse = DenseMatrix::LUSolve(hierarchy.getCoarseMatrix(), bCoarse);
+                for (index i = 0; i < X[currLvl].getDimension(); ++i) {
+                    X[currLvl][i] = xCoarse[i];
+                }
+            }
+        } else {
+            if (currLvl == finest) {
+                maxVisits = 1.0;
+            } else {
+                maxVisits = hierarchy.cycleIndex(currLvl) * numVisits[currLvl - 1];
+            }
+
+            if (numVisits[currLvl] < static_cast<count>(maxVisits)) {
+                nextLvl = currLvl + 1;
+            } else {
+                nextLvl = currLvl - 1;
+            }
+        }
+
+        if (nextLvl < finest)
+            break;
+
+        if (nextLvl > currLvl) { // preProcess
+            numVisits[currLvl]++;
+
+            if (hierarchy.getType(nextLvl) != ELIMINATION) {
+                X[currLvl] = smoother.relax(hierarchy.at(currLvl).getLaplacian(), B[currLvl],
+                                            X[currLvl], status.numPreSmoothIters);
+            }
+
+            if (hierarchy.getType(nextLvl) == ELIMINATION) {
+                hierarchy.at(nextLvl).restrict(B[currLvl], B[nextLvl], bStages[nextLvl]);
+            } else {
+                hierarchy.at(nextLvl).restrict(
+                    B[currLvl] - hierarchy.at(currLvl).getLaplacian() * X[currLvl], B[nextLvl]);
+            }
+
+            hierarchy.at(nextLvl).coarseType(X[currLvl], X[nextLvl]);
+
+            clearHistory(nextLvl);
+        } else { // postProcess
+            if (currLvl == coarsest || hierarchy.getType(currLvl + 1) != ELIMINATION) {
+                minRes(currLvl, X[currLvl],
+                       B[currLvl] - hierarchy.at(currLvl).getLaplacian() * X[currLvl]);
+            }
+
+            if (nextLvl > finest) {
+                saveIterate(nextLvl, X[nextLvl],
+                            B[nextLvl] - hierarchy.at(nextLvl).getLaplacian() * X[nextLvl]);
+            }
+
+            if (hierarchy.getType(currLvl) == ELIMINATION) {
+                hierarchy.at(currLvl).interpolate(X[currLvl], X[nextLvl], bStages[currLvl]);
+            } else {
+                Vector xf = X[nextLvl];
+                hierarchy.at(currLvl).interpolate(X[currLvl], xf);
+                X[nextLvl] += xf;
+            }
+
+            if (hierarchy.getType(currLvl) != ELIMINATION) {
+                X[nextLvl] = smoother.relax(hierarchy.at(nextLvl).getLaplacian(), B[nextLvl],
+                                            X[nextLvl], status.numPostSmoothIters);
+            }
+        }
+
+        currLvl = nextLvl;
+    } // while
+
+    // post-cycle finest
+    if ((int64_t)hierarchy.size() > finest + 1 && hierarchy.getType(finest + 1) != ELIMINATION) {
+        // Do an iterate recombination on calculated solutions
+        minRes(finest, X[finest], B[finest] - hierarchy.at(finest).getLaplacian() * X[finest]);
+    }
+
+    X[finest] -= X[finest].mean();
+    x = X[finest];
+}
+
+template <class Matrix>
+void SolverLamg<Matrix>::saveIterate(const index level, const Vector &x, const Vector &r) {
+    // update latest pointer
+    index i = latestIterate[level];
+    latestIterate[level] = (i + 1) % MAX_COMBINED_ITERATES;
+
+    // update numIterates
+    if (numActiveIterates[level] < MAX_COMBINED_ITERATES) {
+        numActiveIterates[level]++;
+    }
+
+    // update history array
+    history[level][i] = x;
+    rHistory[level][i] = r;
+}
+
+template <class Matrix>
+void SolverLamg<Matrix>::clearHistory(const index level) {
+    latestIterate[level] = 0;
+    numActiveIterates[level] = 0;
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_NUMERICS_LAMG_SOLVER_LAMG_HPP_

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

@@ -0,0 +1,151 @@
+/*
+ * LinearSolver.hpp
+ *
+ *  Created on: 30.10.2014
+ *      Author: Michael Wegner (michael.wegner@student.kit.edu)
+ */
+
+#ifndef NETWORKIT_NUMERICS_LINEAR_SOLVER_HPP_
+#define NETWORKIT_NUMERICS_LINEAR_SOLVER_HPP_
+
+#include <functional>
+#include <limits>
+#include <networkit/algebraic/Vector.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/** Describes the status of a LinearSolver after the solver finished. */
+struct SolverStatus {
+    count numIters;  // number of iterations needed during solve phase
+    double residual; // absolute final residual
+    bool converged;  // flag of conversion status
+};
+
+/**
+ * Abstract base class for solvers that solve linear systems.
+ */
+template <class Matrix>
+class LinearSolver {
+protected:
+    double tolerance;
+
+public:
+    /**
+     * Construct an abstract solver with the given @a tolerance. The relative residual
+     * ||Ax-b||/||b|| should be less than or equal to
+     * @a tolerance after the solver finished.
+     * @param tolerance
+     */
+    LinearSolver(const double tolerance) : tolerance(tolerance) {}
+    virtual ~LinearSolver() = default;
+
+    /**
+     * Sets the solver up for the specified @a matrix.
+     * @param matrix
+     */
+    virtual void setup(const Matrix &matrix) = 0;
+
+    /**
+     * Sets the solver up for the Laplacian matrix of the @a graph specified.
+     * @param graph
+     */
+    virtual void setup(const Graph &graph);
+
+    /**
+     * Sets the solver up for the specified @a matrix where the underlying graph has to be
+     * connected.
+     * @param matrix
+     */
+    virtual void setupConnected(const Matrix &matrix) = 0;
+
+    /**
+     * Sets the solver up for the Laplacian matrix of the @a graph specified. The graph has to be
+     * connected.
+     * @param graph
+     */
+    virtual void setupConnected(const Graph &graph);
+
+    /**
+     * Abstract solve function that computes @a result for the given right-hand side @a rhs and the
+     * matrix that has been setup in @ref setup.
+     * @param rhs
+     * @param result
+     * @param maxConvergenceTime
+     * @param maxIterations
+     * @return A @ref SolverStatus object which provides some statistics like the final absolute
+     * residual.
+     */
+    virtual SolverStatus solve(const Vector &rhs, Vector &result,
+                               count maxConvergenceTime = 5 * 60 * 1000,
+                               count maxIterations = std::numeric_limits<count>::max()) const = 0;
+
+    /**
+     * Abstract parallel solve function that computes 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
+     * @return A vector of @ref SolverStatus objects for each right hand side.
+     * @note If the solver does not support parallelism during solves, this function falls back to
+     * solving the systems sequentially.
+     */
+    virtual 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;
+
+    /**
+     * 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 {
+        count n = rhsSize.first;
+        count m = rhsSize.second;
+        Vector rhs(m);
+        Vector result(m);
+        for (index i = 0; i < n; ++i) {
+            solve(rhsLoader(i, rhs), result, maxConvergenceTime, maxIterations);
+            resultProcessor(i, result);
+        }
+    }
+};
+
+template <class Matrix>
+void LinearSolver<Matrix>::setup(const Graph &graph) {
+    setup(Matrix::laplacianMatrix(graph));
+}
+
+template <class Matrix>
+void LinearSolver<Matrix>::setupConnected(const Graph &graph) {
+    setupConnected(Matrix::laplacianMatrix(graph));
+}
+
+template <class Matrix>
+std::vector<SolverStatus>
+LinearSolver<Matrix>::parallelSolve(const std::vector<Vector> &rhs, std::vector<Vector> &results,
+                                    count maxConvergenceTime, count maxIterations) const {
+    std::vector<SolverStatus> stats(rhs.size());
+    for (index i = 0; i < rhs.size(); ++i) {
+        stats[i] = solve(rhs[i], results[i], maxConvergenceTime, maxIterations);
+    }
+    return stats;
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_NUMERICS_LINEAR_SOLVER_HPP_

package/vendor/include/networkit/numerics/Preconditioner/DiagonalPreconditioner.hpp

@@ -0,0 +1,61 @@
+/*
+ * DiagonalPreconditioner.hpp
+ *
+ *  Created on: Apr 23, 2016
+ *      Author: Michael Wegner (michael.wegner@student.kit.edu)
+ */
+
+#ifndef NETWORKIT_NUMERICS_PRECONDITIONER_DIAGONAL_PRECONDITIONER_HPP_
+#define NETWORKIT_NUMERICS_PRECONDITIONER_DIAGONAL_PRECONDITIONER_HPP_
+
+#include <networkit/algebraic/CSRMatrix.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup numerics
+ * Simple preconditioner that approximates the matrix by a
+ * diagonal matrix.
+ */
+class DiagonalPreconditioner {
+public:
+    /** Default constructor */
+    DiagonalPreconditioner() = default;
+
+    /**
+     * Constructs a diagonal preconditioner for the matrix @a A.
+     * @param A
+     */
+    DiagonalPreconditioner(const CSRMatrix &A) : inv_diag(A.numberOfRows()) {
+        assert(A.numberOfColumns() == A.numberOfRows());
+
+        // Diagonal preconditioner just needs to store the inverse diagonal of A
+        inv_diag = A.diagonal();
+#pragma omp parallel for
+        for (omp_index i = 0; i < static_cast<omp_index>(inv_diag.getDimension()); ++i) {
+            if (inv_diag[i] > 0)
+                inv_diag[i] = 1.0 / inv_diag[i];
+        }
+    }
+
+    virtual ~DiagonalPreconditioner() = default;
+
+    /**
+     * Returns the preconditioned right-hand-side \f$P(b) = D(A)^{-1}b\f$.
+     */
+    Vector rhs(const Vector &b) const {
+        assert(b.getDimension() == inv_diag.getDimension());
+        Vector out(b.getDimension());
+        for (index i = 0; i < b.getDimension(); ++i) {
+            out[i] = inv_diag[i] * b[i];
+        }
+        return out;
+    }
+
+private:
+    Vector inv_diag;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_NUMERICS_PRECONDITIONER_DIAGONAL_PRECONDITIONER_HPP_

package/vendor/include/networkit/numerics/Preconditioner/IdentityPreconditioner.hpp

@@ -0,0 +1,36 @@
+/*
+ * IdentityPreconditioner.hpp
+ *
+ *  Created on: Apr 23, 2016
+ *      Author: Michael Wegner (michael.wegner@student.kit.edu)
+ */
+
+#ifndef NETWORKIT_NUMERICS_PRECONDITIONER_IDENTITY_PRECONDITIONER_HPP_
+#define NETWORKIT_NUMERICS_PRECONDITIONER_IDENTITY_PRECONDITIONER_HPP_
+
+namespace NetworKit {
+
+/**
+ * @ingroup numerics
+ * Simple preconditioner that returns the given vector unchanged.
+ */
+class IdentityPreconditioner {
+public:
+    /** Default constructor */
+    IdentityPreconditioner() = default;
+    /**
+     * Constructs an identity preconditioner for the matrix @a A.
+     * @param A
+     */
+    IdentityPreconditioner(const CSRMatrix &) {}
+    virtual ~IdentityPreconditioner() = default;
+
+    /**
+     * Returns the preconditioned right-hand-side \f$P(b) = b\f$.
+     */
+    Vector rhs(const Vector &b) const { return b; }
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_NUMERICS_PRECONDITIONER_IDENTITY_PRECONDITIONER_HPP_

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

@@ -0,0 +1,37 @@
+/*
+ * Smoother.hpp
+ *
+ *  Created on: 31.10.2014
+ *      Author: Michael Wegner (michael.wegner@student.kit.edu)
+ */
+
+#ifndef NETWORKIT_NUMERICS_SMOOTHER_HPP_
+#define NETWORKIT_NUMERICS_SMOOTHER_HPP_
+
+#include <networkit/algebraic/CSRMatrix.hpp>
+#include <networkit/algebraic/Vector.hpp>
+
+#include <limits>
+#include <networkit/algebraic/DynamicMatrix.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup numerics
+ * Abstract base class of a smoother.
+ */
+template <class Matrix>
+class Smoother {
+public:
+    Smoother() {}
+    virtual ~Smoother() {}
+
+    virtual Vector relax(const Matrix &A, const Vector &b, const Vector &initialGuess,
+                         count maxIterations = std::numeric_limits<count>::max()) const = 0;
+    virtual Vector relax(const Matrix &A, const Vector &b,
+                         count maxIterations = std::numeric_limits<count>::max()) const = 0;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_NUMERICS_SMOOTHER_HPP_

package/vendor/include/networkit/overlap/HashingOverlapper.hpp

@@ -0,0 +1,28 @@
+/*
+ * HashingOverlapper.hpp
+ *
+ *  Created on: 31.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_OVERLAP_HASHING_OVERLAPPER_HPP_
+#define NETWORKIT_OVERLAP_HASHING_OVERLAPPER_HPP_
+
+#include <functional>
+
+#include <networkit/overlap/Overlapper.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup overlap
+ * Determines the overlap of multiple partitions by hashing partition identifiers.
+ */
+class HashingOverlapper final : public Overlapper {
+
+public:
+    Partition run(const Graph &G, const std::vector<Partition> &clusterings) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_OVERLAP_HASHING_OVERLAPPER_HPP_

package/vendor/include/networkit/overlap/Overlapper.hpp

@@ -0,0 +1,27 @@
+/*
+ * Overlapper.hpp
+ *
+ *  Created on: 30.10.2012
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_OVERLAP_OVERLAPPER_HPP_
+#define NETWORKIT_OVERLAP_OVERLAPPER_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup overlap
+ * Abstract base class for algorithms which determine the overlap of multiple partitions.
+ */
+class Overlapper {
+
+public:
+    virtual Partition run(const Graph &G, const std::vector<Partition> &clusterings) = 0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_OVERLAP_OVERLAPPER_HPP_