@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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

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

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

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