NAME

       riesz - approximate a Riesz representer

SYNOPSYS

       The riesz function is now obsolete: it has been now suppersetted by the integrate function
       see integrate(4).

        template <class Expr>
        field riesz (space, Expr expr);
        field riesz (space, Expr expr, quadrature_option_type);
        field riesz (space, Expr expr, domain);
        field riesz (space, Expr expr, domain, quadrature_option_type);

       The domain can be also provided by its name as a string.  The old-fashioned code:

NOTE

       The riesz function is now obsolete: it has been now suppersetted by the integrate function
       see integrate(4).  The old-fashioned code:

            field l1h = riesz (Xh, f);
            field l2h = riesz (Xh, f, "boundary");

       writes now:

            test v (Xh);
            field l1h = integrate (f*v);
            field l2h = integrate ("boundary", f*v);

       The riesz function is still present in the library for backward compatibility purpose.

DESCRIPTION

       Let  f be any continuous function, its Riesz representer in the finite element space Xh on
       the domain Omega is defind by:

                       /
                       |
         dual(lh,vh) = |      f(x) vh(x) dx
                       |
                      / Omega

       for all vh in Xh, where dual denotes the duality between Xh and  its  dual.  As  Xh  is  a
       finite  dimensional  space,  its  dual  is identified as Xh and the duality product as the
       Euclidian one.  The Riesz representer is thus the lh field of Xh where its i-th degree  of
       freedom is:

                       /
                       |
         dual(lh,vh) = |      f(x) phi_i(x) dx
                       |
                      / Omega

       where  phi_i  is  the  i-th  basis  function  in Xh.  The integral is evaluated by using a
       quadrature formula.  By default the quadrature formule is the Gauss  one  with  the  order
       equal  to  2*k-1  where $k is the polynomial degree in Xh.  Alternative quadrature formula
       and order is available by passing an optional variable to riesz.

       The function riesz implements the approximation of the Riesz  representer  by  using  some
       quadrature formula for the evaluation of the integrals.  Its argument can be any function,
       class-function or linear or nonlinear expressions mixing fields and continuous functions.

EXAMPLE

       The following code compute the Riesz representant, denoted by lh of f(x), and the integral
       of f over the domain omega:

         Float f(const point& x);
         ...
         space Xh (omega_h, "P1");
         field lh = riesz (Xh, f);
         Float int_f = dual(lh, 1);

OPTIONS

       An  optional  argument  specifies  the  quadrature formula used for the computation of the
       integral.  The domain of integration is by default  the  mesh  associated  to  the  finite
       element  space.  An alternative domain dom, e.g. a part of the boundary can be supplied as
       an extra argument.  This domain can be also a band associated  to  the  banded  level  set
       method.

IMPLEMENTATION

       template <class T, class M, class Function>
       inline
       field_basic<T,M>
       riesz (
           const space_basic<T,M>&       Xh,
           const Function&               f,
           const quadrature_option_type& qopt
              = quadrature_option_type())

IMPLEMENTATION

       template <class T, class M, class Function>
       field_basic<T,M>
       riesz (
           const space_basic<T,M>&       Xh,
           const Function&               f,
           const geo_basic<T,M>&         dom,
           const quadrature_option_type& qopt
              = quadrature_option_type())

IMPLEMENTATION

       template <class T, class M, class Function>
       field_basic<T,M>
       riesz (
           const space_basic<T,M>&       Xh,
           const Function&               f,
           std::string                   dom_name,
           const quadrature_option_type& qopt
              = quadrature_option_type())

IMPLEMENTATION

       template <class T, class M, class Function>
       field_basic<T,M>
       riesz (
           const space_basic<T,M>&       Xh,
           const Function&               f,
           const band_basic<T,M>&        gh,
           const quadrature_option_type& qopt
              = quadrature_option_type())

SEE ALSO

       integrate(4), integrate(4)