NAME

       test - test-function in variational formulation (rheolef-7.1)

DESCRIPTION

       This class, and its associated trial one, is used for test and trial functions involved in
       variational formulations. Variational formulations are specified by expressions of the C++
       language.

       A test function is the formal argument involved in the expression for the integrate(3)
       function:

           geo omega ("circle");
           space Xh (omega, "P1");
           test v (Xh);
           field lh = integrate (omega, 2*v);

        For a bilinear form(2), the test function represents its second formal argument, while
       its first one is referred to as the trial one:

           trial u (Xh);
           test  v (Xh);
           form a = integrate (omega, dot(grad(u),grad(v)));

IMPLEMENTATION

       This documentation has been generated from file main/lib/test.h

       The test and trial classes are simply aliases to the test_basic class:

       typedef test_basic<Float,rheo_default_memory_model,details::vf_tag_01> test;
       typedef test_basic<Float,rheo_default_memory_model,details::vf_tag_10> trial;

       The test_basic class provides an interface, via the smart_pointer(7) class family, to a
       data container:

       template <class T, class M, class VfTag>
       class test_basic : public smart_pointer<test_rep<T,M> > {
       public :
       // typedefs:

           typedef test_rep<T,M>                    rep;
           typedef smart_pointer<rep>               base;
           typedef typename rep::size_type          size_type;
           typedef typename rep::memory_type        memory_type;
           typedef typename rep::value_type         value_type;
           typedef typename rep::scalar_type        scalar_type;
           typedef typename rep::float_type         float_type;
           typedef typename rep::geo_type           geo_type;
           typedef typename rep::space_type         space_type;
           typedef typename rep::diff_type          diff_type;
           typedef VfTag                            vf_tag_type;
           typedef typename details::dual_vf_tag<VfTag>::type
                                                    vf_dual_tag_type;
           typedef test_basic<T,M,VfTag>            self_type;
           typedef test_basic<T,M,vf_dual_tag_type> dual_self_type;

       // allocator/deallocator:

           explicit test_basic (const space_type& V) : base(new_macro(rep(V))) {}

       // accessors:

           const space_type&  get_vf_space()  const { return base::data().get_vf_space(); }
           static const space_constant::valued_type valued_hint = rep::valued_hint;
           space_constant::valued_type valued_tag() const { return base::data().valued_tag(); }
           size_type n_derivative() const { return base::data().n_derivative(); }

           size_type size() const { return get_vf_space().size(); }
           details::test_component<T,M,VfTag> operator[] (size_type i_comp) const;

       };

AUTHOR

       Pierre  Saramito  <Pierre.Saramito@imag.fr>

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.