gsKroneckerOp.h

Go to the documentation of this file.

#pragma once

#include <gsSolver/gsLinearOperator.h>

namespace gismo
{

template <class T>
class gsKroneckerOp GISMO_FINAL : public gsLinearOperator<T>
{
    typedef typename gsLinearOperator<T>::Ptr BasePtr;
public:

    typedef memory::shared_ptr<gsKroneckerOp> Ptr;

    typedef memory::unique_ptr<gsKroneckerOp> uPtr;

    gsKroneckerOp(std::vector< BasePtr > ops)
        : m_ops(give(ops))
    { }

    gsKroneckerOp(BasePtr op0, BasePtr op1)
        : m_ops(2)
    { m_ops[0] = give(op0); m_ops[1] = give(op1); }

    gsKroneckerOp(BasePtr op0, BasePtr op1, BasePtr op2)
        : m_ops(3)
    { m_ops[0] = give(op0); m_ops[1] = give(op1); m_ops[2] = give(op2); }

    static uPtr make(std::vector< BasePtr > ops)
    { return uPtr( new gsKroneckerOp(give(ops)) ); }

    static uPtr make(BasePtr op0, BasePtr op1)
    { return uPtr( new gsKroneckerOp(give(op0),give(op1)) ); }

    static uPtr make(BasePtr op0, BasePtr op1, BasePtr op2)
    { return uPtr( new gsKroneckerOp(give(op0),give(op1),give(op2)) ); }

    void addOperator( BasePtr op )
    { m_ops.push_back(give(op)); }

    virtual void apply(const gsMatrix<T> & input, gsMatrix<T> & x) const;
    virtual index_t rows() const;
    virtual index_t cols() const;

    const std::vector<BasePtr>& getOps() const { return m_ops; }

    static void apply(const std::vector<BasePtr> & ops, const gsMatrix<T> & input, gsMatrix<T> & x);

private:
    std::vector<BasePtr> m_ops;
};

}

#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsKroneckerOp.hpp)
#endif