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