---
name: "test"
section: "2rheolef"
platform: "linux"
package: "librheolef-dev"
version: "7.2-4"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/test/2rheolef"
---

# test(2rheolef)

test-function in variational formulation (rheolef-7.2)

## NAME

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

## 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:
    using rep  = test_rep<T,M>;
    using base = smart_pointer<rep>;
    using size_type      = typename rep::size_type;
    using memory_type    = typename rep::memory_type;
    using value_type     = typename rep::value_type;
    using scalar_type    = typename rep::scalar_type;
    using float_type     = typename rep::float_type;
    using geo_type       = typename rep::geo_type;
    using space_type     = typename rep::space_type;
    using diff_type      = typename rep::diff_type;
    using is_elementwise = typename rep::is_elementwise;
    using vf_tag_type      = VfTag;
    using vf_dual_tag_type = typename details::dual_vf_tag<VfTag>::type;
    using self_type        = test_basic<T,M,VfTag>;
    using dual_self_type   = test_basic<T,M,vf_dual_tag_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.**