.\"
.de Id
..
.de Sp
.if n .sp
.if t .sp 0.4
..
.TH basis 7rheolef "rheolef-6.7" "rheolef-6.7" "rheolef-6.7"
.\" label: /*Class:basis
.SH NAME
\fBbasis\fP - polynomial basis
.\" skip: @cindex  polynomial basis
.\" skip: @clindex basis
.\" skip: @cindex  reference element
.\" skip: @clindex reference_element
.SH SYNOPSYS

The \fBbasis\fP class defines functions that evaluates a polynomial
basis and its derivatives on a point. The polynomial basis
is designated by a string, e.g. "P0", "P1", "P2", "bubble",...
indicating the basis. The basis depends also of the reference element:
triangle, square, tetrahedron (see reference_element(2)).
For instance, on a square, the "P1"
string designates the common Q1 four-nodes basis on the reference square.
.PP
The nodes associated to the Lagrange polynomial basis
are also available by its associated accessor.
.PP
.SH IMPLEMENTATION NOTE

The \fBbasis\fP class
is a see smart_pointer(2)) class on a \fBbasis_rep\fP class that is a pure virtual base class
for effective bases, e.g. basis_P1, basis_P1, etc.
.\" skip start:AUTHORS:

.\" skip start:DATE:
.\" END
.SH IMPLEMENTATION
.\" begin_example
.Sp
.nf
template<class T>
class basis_basic : public smart_pointer<basis_rep<T> > {
public:

// typedefs:

    typedef basis_rep<T>                           rep;
    typedef smart_pointer<rep>                     base;
    typedef typename basis_rep<T>::size_type       size_type;

// allocators:

    basis_basic (std::string name = "");

// accessors:

    std::string name() const;
    size_type   degree() const;
    size_type   size (reference_element hat_K) const;

    void hat_node(
        reference_element              hat_K,
        std::vector<point_basic<T> >&  hat_node) const;
    void hat_node(
        reference_element                               hat_K,
        typename std::vector<point_basic<T> >::iterator hat_node) const;

    void eval(
        reference_element     hat_K,
        const point_basic<T>& hat_x,
        std::vector<T>&       values) const;
    void eval(
        reference_element                 hat_K,
        const point_basic<T>&             hat_x,
        typename std::vector<T>::iterator values) const;

    void grad_eval(
        reference_element    hat_K,
        const point_basic<T>&         hat_x,
        std::vector<point_basic<T> >&  values) const;
    void grad_eval(
        reference_element                               hat_K,
        const point_basic<T>&                           hat_x,
        typename std::vector<point_basic<T> >::iterator values) const;
};
typedef basis_basic<Float> basis;
.Sp
.fi
.\" end_example

.\" LENGTH = 2
.SH SEE ALSO
reference_element(2), smart_pointer(2)