interface.hpp

Go to the documentation of this file.

#ifndef IRLBA_MATRIX_INTERFACE_HPP
#define IRLBA_MATRIX_INTERFACE_HPP
 
#include <memory>
 
#include "Eigen/Dense"
 
namespace irlba {
 
template<class EigenVector_>
class Workspace {
public:
    Workspace() = default;
    Workspace(Workspace&&) = default;
    Workspace(const Workspace&) = default;
    Workspace& operator=(Workspace&&) = default;
    Workspace& operator=(const Workspace&) = default;
    virtual ~Workspace() {}
    virtual void multiply(const EigenVector_& right, EigenVector_& output) = 0;
};
 
template<class EigenVector_>
class AdjointWorkspace {
public:
    AdjointWorkspace() = default;
    AdjointWorkspace(AdjointWorkspace&&) = default;
    AdjointWorkspace(const AdjointWorkspace&) = default;
    AdjointWorkspace& operator=(AdjointWorkspace&&) = default;
    AdjointWorkspace& operator=(const AdjointWorkspace&) = default;
    virtual ~AdjointWorkspace() {}
    virtual void multiply(const EigenVector_& right, EigenVector_& output) = 0;
};
 
template<class EigenMatrix_>
class RealizeWorkspace { 
public:
    RealizeWorkspace() = default;
    RealizeWorkspace(RealizeWorkspace&&) = default;
    RealizeWorkspace(const RealizeWorkspace&) = default;
    RealizeWorkspace& operator=(RealizeWorkspace&&) = default;
    RealizeWorkspace& operator=(const RealizeWorkspace&) = default;
    virtual ~RealizeWorkspace() {}
    virtual const EigenMatrix_& realize(EigenMatrix_& buffer) = 0;
 
    void realize_copy(EigenMatrix_& buffer) {
        const auto& out = realize(buffer);
        if (&out != &buffer) {
            buffer = out;
        }
    }
};
 
template<class EigenVector_, class EigenMatrix_>
class Matrix {
public:
    Matrix() = default;
    Matrix(Matrix&&) = default;
    Matrix(const Matrix&) = default;
    Matrix& operator=(Matrix&&) = default;
    Matrix& operator=(const Matrix&) = default;
    virtual ~Matrix() {}
public:
    virtual Eigen::Index rows() const = 0;
 
    virtual Eigen::Index cols() const = 0;
 
public:
    virtual std::unique_ptr<Workspace<EigenVector_> > new_workspace() const = 0;
 
    virtual std::unique_ptr<AdjointWorkspace<EigenVector_> > new_adjoint_workspace() const = 0;
 
    virtual std::unique_ptr<RealizeWorkspace<EigenMatrix_> > new_realize_workspace() const = 0;
 
public:
    std::unique_ptr<Workspace<EigenVector_> > new_known_workspace() const {
        return new_workspace();
    }
 
    std::unique_ptr<AdjointWorkspace<EigenVector_> > new_known_adjoint_workspace() const {
        return new_adjoint_workspace();
    }
 
    std::unique_ptr<RealizeWorkspace<EigenMatrix_> > new_known_realize_workspace() const {
        return new_realize_workspace();
    }
};
 
}
 
#endif