gsBasisFun.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsCore/gsFunction.h>
 
namespace gismo
{
 
template<class T> class gsBasis;
 
template<class T>
class gsBasisFun : public gsFunction<T>
{
private:
    gsBasisFun() { }
    
public:
    typedef memory::shared_ptr< gsBasisFun > Ptr;
 
    typedef memory::unique_ptr< gsBasisFun > uPtr;
 
    gsBasisFun(const gsBasis<T> & basis, unsigned const i);
 
    ~gsBasisFun() { } //destructor
 
    GISMO_CLONE_FUNCTION(gsBasisFun)
 
public:
 
    virtual std::ostream &print(std::ostream &os) const
    {
        os << "gsBasisFun"; return os;
    }
 
 
    short_t domainDim () const {return m_basis.domainDim();}
 
    short_t targetDim () const {return m_basis.targetDim();}
 
    gsMatrix<T> support() const;
 
    void eval_into (const gsMatrix<T>& u, gsMatrix<T>& result ) const;
 
    void deriv_into(const gsMatrix<T>& u, gsMatrix<T>& result ) const;
 
    void setFunction( unsigned const & i );
 
    void first();
 
    bool next();
 
    bool valid();
 
    unsigned index() const { return m_index; }
    
    // temporary hack
    virtual const gsBasisFun & piece(const index_t) const
    {
        return *this; 
    }
 
 
// Data members
private:
    const gsBasis<T> & m_basis;
    unsigned m_index;
 
}; // class gsBasisFun
 
 
template<class T>
gsBasisFun<T>::gsBasisFun(const gsBasis<T> & basis, const unsigned i )
: m_basis(basis), m_index(i) 
{ 
    GISMO_ASSERT( i<unsigned(m_basis.size()),"Invalid basis function index" );
}
 
template<class T> void
gsBasisFun<T>::setFunction( unsigned const & i )
{
    GISMO_ASSERT( i<unsigned(m_basis.size()),"Invalid basis function index" );
    m_index = i;
}
 
template<class T> void
gsBasisFun<T>::first()
{
    m_index = 0;
}
 
template<class T> bool
gsBasisFun<T>::next()
{
    return ( ++m_index  < static_cast<unsigned>(m_basis.size()) );
}
 
template<class T> bool
gsBasisFun<T>::valid()
{
    return ( m_index  < static_cast<unsigned>(m_basis.size()) );
}
 
template<class T> gsMatrix<T>
gsBasisFun<T>::support()  const
{
    return m_basis.support(m_index);
}
 
template<class T> void
gsBasisFun<T>::eval_into(const gsMatrix<T>& u, gsMatrix<T>& result )  const
{
    m_basis.evalSingle_into(m_index, u, result);
}
 
template<class T> void
gsBasisFun<T>::deriv_into(const gsMatrix<T>& u, gsMatrix<T>& result )  const
{
    m_basis.derivSingle_into(m_index, u, result);
}
 
#ifdef GISMO_WITH_PYBIND11
 
  void pybind11_init_gsBasisFun(pybind11::module &m);
 
#endif // GISMO_WITH_PYBIND11
 
} // namespace gismo