NAME

       riesz - approximate a Riesz representer

SYNOPSYS

        template <class Function>
        field riesz (const space& Xh, const Expr& expr,
               quadrature_option_type qopt = default_value);

        template <class Function>
        field riesz (const space& Xh, const Expr& expr,
               const geo& domain, quadrature_option_type qopt = default_value);

NOTE

       This  function  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 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>
       field_basic<T,M>
       riesz (
           const space_basic<T,M>&       Xh,
           const Function&               f,
           const quadrature_option_type& qopt
              = quadrature_option_type(quadrature_option_type::max_family))

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(quadrature_option_type::max_family))

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(quadrature_option_type::max_family))

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(quadrature_option_type::max_family))

SEE ALSO

       integrate(4)