NAME

       basis_on_pointset - pre-evaluated polynomial basis

SYNOPSIS

       The basis_on_pointset class is able to evaluates a polynomial basis and its derivatives on
       a set of point  of  the  reference  element  (see  reference_element(2)).   The  basis  is
       described by the basis class (see basis(2)).  The set of points could be either quadrature
       nodes on the reference element (see quadrature(2)) or Lagrange nodes associated to another
       basis.   For  application  of  an  integration of jump and average values of a discontuous
       approximation on a side, the set of nodes could be defined on a specific  side  only.   In
       all  these cases, the evaluation of polynomials could be performed one time for all on the
       reference element and its result stored and reused for  all  elements  of  the  mesh:  the
       speedup is important, espcially for high order polynomials.

IMPLEMENTATION

       template<class T>
       class basis_on_pointset: public smart_pointer<basis_on_pointset_rep<T> > {
       public:

         typedef basis_on_pointset_rep<T>          rep;
         typedef smart_pointer<rep>                base;
         typedef typename rep::size_type           size_type;
         typedef typename rep::const_iterator      const_iterator;
         typedef typename rep::const_iterator_grad const_iterator_grad;

       // allocators:

         basis_on_pointset ();
         basis_on_pointset (const quadrature<T>&  quad, const basis_basic<T>& b);
         basis_on_pointset (const basis_basic<T>& nb,   const basis_basic<T>& b);

       // modifiers:

         void set (const quadrature<T>&  quad, const basis_basic<T>& b);
         void set (const basis_basic<T>& nb,   const basis_basic<T>& b);

       // accessors:

         const basis_basic<T>& get_basis() const;
         size_type pointset_size (reference_element hat_K) const;

       // reference element and pointset:

         void evaluate      (reference_element hat_K, size_type q) const;
         void evaluate_grad (reference_element hat_K, size_type q) const;

         // for a specific node instead of a pointset:
         void evaluate      (reference_element hat_K, const point_basic<T>& hat_xq) const;
         void evaluate_grad (reference_element hat_K, const point_basic<T>& hat_xq) const;

         // side trace, for DG:
         void restrict_on_side (reference_element tilde_L, const side_information_type& sid);

       // accessors to values:

         const T& value (size_type loc_idof) const;
         const point_basic<T>& grad_value (size_type loc_idof) const;

         const_iterator      begin() const;
         const_iterator      end() const;
         const_iterator_grad begin_grad() const;
         const_iterator_grad end_grad() const;
       };

SEE ALSO

       reference_element(2), basis(2), quadrature(2)

COPYRIGHT

       Copyright  (C) 2000-2018 Pierre Saramito <Pierre.Saramito@imag.fr> GPLv3+: GNU GPL version
       3 or later <http://gnu.org/licenses/gpl.html>.  This is free software:  you  are  free  to
       change and redistribute it.  There is NO WARRANTY, to the extent permitted by law.