gsMvLegandreBasis.h

#pragma once
#include <cmath>
 
//#include <gismo.h>
#include <gsCore/gsForwardDeclarations.h>
//#include "gsMvLegendreBasis.hpp"
#include <gsUtils/gsCombinatorics.h>
 
namespace gismo
{
 
// forward declaration
template< class T>  class gsMvLegendreBasis;
template <class T>  class gsMvLegendrePoly;
 
template<class T>
class gsMvLegendreBasis : public gsBasis<T>
{
public:
    typedef gsBasis<T> Base;
 
    typedef T Scalar_t;
 
    typedef gsMvLegendrePoly<T> GeometryType;
 
    typedef gsMvLegendreBasis<T> BoundaryBasisType;
 
    static const int Dim = 1;
 
    typedef memory::shared_ptr< gsMvLegendreBasis > Ptr;
 
    typedef memory::unique_ptr< gsMvLegendreBasis > uPtr;
 
    static Ptr Make ( const gsVector<T> & vec, const T & start, const T & end)  // TODO: remove?
    { return Ptr( new gsMvLegendreBasis(vec,start,end) ); }
 
public:
    explicit gsMvLegendreBasis (const index_t deg, const T & start = 1, const T & end = 1) :
    m_ubasis(deg,start, m_end)
    { }
 
public:
 
    int dim() const { return Dim; }
 
    void active_into(const gsMatrix<T> & u, gsMatrix<index_t>& result) const;
 
    void numActive_into(const gsMatrix<T> & u, gsVector<index_t>& result) const
    {
        result.setConstant(1, u.cols(), m_p+1);
    }
 
    gsMatrix<T> support() const
    {
        gsMatrix<T> res(1,2);
        res << m_start , m_end ;
        return res;
    }
 
    gsMatrix<T> support(const index_t & i) const
    {
        return support();
    }
 
    void eval_into(const gsMatrix<T> & u, gsMatrix<T>& result) const;
 
    void deriv_into(const gsMatrix<T> & u, gsMatrix<T>& result ) const;
 
    void deriv2_into(const gsMatrix<T> & u, gsMatrix<T>& result ) const;
 
    GISMO_CLONE_FUNCTION(gsMvLegendreBasis)
 
    GISMO_MAKE_GEOMETRY_NEW
 
    std::ostream &print(std::ostream &os) const
    {
        os << "MvLegendre Basis: deg=" << this->degree()
           << ", size="<< this->size()
           << ", interval= [" << m_start << "," << m_end << "].\n";
        return os;
    }
 
    int size() const { return m_p+1; }
 
    gsDomain<T> * domain() const
    { GISMO_NO_IMPLEMENTATION }
 
    short_t degree() const
    {
        return m_p;
    }
 
private:
 
    inline T _getA(const index_t j)
    {
        return (T)(2*j-1)/j;
        return math::sqrt((T)(2*j-1)) * math::sqrt((T)(2*j+1)) / (j*math::sqrt((T)3));
    }
 
    inline T _getB(const index_t j)
    {
        return 0;
    }
    
    inline T _getC(const index_t j)
    {
        return (T)(j-1)/j;
        return _getA(j) / _getA(j-1);
    }
 
private:
    gsLegendreBasis<T> m_ubasis;
}; // class gsMvLegendreBasis
 
} // namespace gismo
 
 
//include the hpp file that contains the file definitions
//#include "gsMvLegendreBasis.hpp"