Loading...
Searching...
No Matches
rheolef::details

## Namespaces

namespace | legendre
namespace | jacobi

## Classes

struct | is_rheolef_arithmetic
struct | is_rheolef_arithmetic< T, typename std::enable_if< std::is_arithmetic< T >::value||std::is_same< typename std::decay< T >::type, double >::value >::type >
struct | upgrade_integral_to_float
struct | upgrade_integral_to_float< Int, typename std::enable_if< std::is_integral< Int >::value, Int >::type >
struct | constructor_copy
struct | clone_copy
struct | no_copy
class | csr_concat_value
class | csr_concat_line
struct | vec_trans
struct | vector_vec_trans
class | csr_concat
struct | is_class_reference< disarray_dis_reference< T, A > >
class | generic_binder1st
struct | generic_binder2nd
struct | assign_op
struct | plus_assign
struct | minus_assign
struct | multiplies_assign
struct | divides_assign
struct | iterator_on_constant
struct | default_set_op_traits< index_set >
struct | is_container< index_set >
struct | is_container_of_mpi_datatype< index_set >
struct | is_class_reference
struct | is_container
struct | is_container_of_mpi_datatype
struct | default_set_op_traits< pair_set< T, A > >
struct | is_container< pair_set< T, A > >
struct | is_container_of_mpi_datatype< pair_set< T, A > >
struct | is_vec
struct | is_vec_expr_v2_arg
class | vec_concat_value
class | vec_concat
struct | is_vec< vec< T, M > >
struct | is_vec_expr_v2_arg< vec< T, M > >
struct | vec_expr_v2_unary
struct | is_vec_expr_v2_arg< vec_expr_v2_unary< Op, Expr > >
struct | vec_expr_v2_binary
struct | is_vec_expr_v2_arg< vec_expr_v2_binary< Op, Expr1, Expr2 > >
struct | vec_expr_v2_binary_traits
struct | vec_expr_v2_binary_traits< Op, Expr1, Expr2, typename std::enable_if< details::is_vec_expr_v2_arg< Expr1 >::value &&details::is_vec_expr_v2_arg< Expr2 >::value >::type >
struct | vec_expr_v2_binary_traits< Op, Expr1, Expr2, typename std::enable_if< details::is_rheolef_arithmetic< Expr1 >::value &&details::is_vec_expr_v2_arg< Expr2 >::value >::type >
struct | vec_expr_v2_binary_traits< Op, Expr1, Expr2, typename std::enable_if< details::is_vec_expr_v2_arg< Expr1 >::value &&details::is_rheolef_arithmetic< Expr2 >::value >::type >
struct | decay_is_same
struct | or_type
struct | or_type<>
struct | or_type< B1 >
struct | or_type< B1, B2 >
struct | or_type< B1, B2, B3, Bn... >
struct | and_type
struct | and_type<>
struct | and_type< B1 >
struct | and_type< B1, B2 >
struct | and_type< B1, B2, B3, Bn... >
struct | not_type
struct | index_list
struct | range_builder
struct | range_builder< MIN, MIN, Is... >
struct | functor_traits
struct | functor_traits< R(C::*)(Args...) const >
struct | true_function_traits
struct | true_function_traits< R(*)(Args...)>
struct | true_function_traits< R(Args...)>
struct | function_traits
struct | function_traits< R(Args...)>
struct | function_traits< R(*)(Args...)>
struct | build_free_function
struct | build_free_function< F, R(Args...)>
struct | build_class_function
struct | build_class_function< C, R(Args...)>
struct | build_class_function< C, R(Args...) const >
struct | build_class_function< C, R(Args...) volatile >
struct | is_functor_with_signature
struct | is_function_with_signature
struct | is_callable_impl
struct | is_callable_impl< F, S, false >
struct | is_callable
struct | is_callable< Signature, Signature >
struct | get_functor_result_impl
struct | get_functor_result_impl< C, R(C::*)(Args...)>
struct | get_functor_result_impl< C, R(C::*)(Args...) const >
struct | get_functor_result_impl< C, R(C::*)(Args...) volatile >
struct | get_functor_result
struct | get_functor_result< F, typename std::enable_if< std::is_member_function_pointer< decltype(&F::operator())>::value >::type >
struct | is_functor
struct | is_functor< F, typename std::enable_if< get_functor_result< F >::value >::type >
struct | is_equal
struct | is_equal< T, T >
struct | is_scalar
struct | is_scalar< int >
struct | is_scalar< const int >
struct | is_scalar< size_t >
struct | is_scalar< double >
struct | is_point
struct | is_point< point_basic< T > >
struct | is_tensor
struct | is_tensor< tensor_basic< T > >
struct | is_tensor3
struct | is_tensor3< tensor3_basic< T > >
struct | is_tensor4
struct | is_tensor4< tensor4_basic< T > >
struct | field_promote_first_argument
struct | field_promote_second_argument
struct | f_constant
struct | is_vector_function
struct | is_vector_function< point_basic< T >(const point_basic< T >)>
class | field_nonlinear_expr
struct | is_expr
struct | is_expr< field_nonlinear_expr< E > >
struct | is_constant
struct | is_function
struct | result_type
struct | result_type< R(const point_basic< T > &)>
struct | result_type< R(*)(const point_basic< T > &)>
struct | constant_promote
struct | constant_promote< int >
struct | constant_promote< size_t >
struct | is_field_expr_v2_constant
struct | memorized_vector
class | memorized_matrix
class | memorized_side_value
struct | differentiate_option
class | field_expr_v2_nonlinear_node_nary
struct | is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_node_nary< F, Exprs... > >
struct | has_field_lazy_interface< field_expr_v2_nonlinear_node_nary< F, Exprs... > >
struct | binop_error
struct | is_error
struct | is_error< binop_error< Op, T1, T2, R > >
struct | generic_unary_traits
struct | unary_plus
struct | generic_unary_traits< unary_plus >
struct | negate
struct | generic_unary_traits< negate >
struct | generic_unary_traits< tr_ >
struct | trans_
struct | generic_unary_traits< trans_ >
struct | norm_
struct | generic_unary_traits< norm_ >
struct | norm2_
struct | generic_unary_traits< norm2_ >
struct | generic_binary_traits
struct | plus_result
struct | plus_result< A1, A2, typename std::enable_if< is_rheolef_arithmetic< A1 >::value &&is_rheolef_arithmetic< A2 >::value >::type >
struct | plus_result< A, A, typename std::enable_if< ! is_rheolef_arithmetic< A >::value >::type >
struct | plus
struct | generic_binary_traits< plus >
struct | minus
struct | generic_binary_traits< minus >
struct | multiplies_result
struct | multiplies_result< S, point_basic< S > >
struct | multiplies_result< S, tensor_basic< S > >
struct | multiplies_result< point_basic< S >, S >
struct | multiplies_result< point_basic< S1 >, point_basic< S2 > >
struct | multiplies_result< point_basic< S1 >, tensor_basic< S2 > >
struct | multiplies_result< tensor_basic< S >, S >
struct | multiplies_result< tensor_basic< S1 >, point_basic< S2 > >
struct | multiplies_result< tensor_basic< S1 >, tensor_basic< S2 > >
struct | multiplies_result< S, tensor3_basic< S > >
struct | multiplies_result< tensor3_basic< S >, S >
struct | multiplies_result< tensor3_basic< S1 >, point_basic< S2 > >
struct | multiplies_result< tensor3_basic< S1 >, tensor_basic< S2 > >
struct | multiplies_result< point_basic< S1 >, tensor3_basic< S2 > >
struct | multiplies_result< tensor_basic< S1 >, tensor3_basic< S2 > >
struct | multiplies_result< tensor3_basic< S1 >, tensor3_basic< S2 > >
struct | multiplies_result< S, tensor4_basic< S > >
struct | multiplies_result< tensor4_basic< S >, S >
struct | multiplies_result< point_basic< S1 >, tensor4_basic< S2 > >
struct | multiplies_result< tensor_basic< S1 >, tensor4_basic< S2 > >
struct | multiplies_result< tensor3_basic< S1 >, tensor4_basic< S2 > >
struct | multiplies_result< tensor4_basic< S1 >, point_basic< S2 > >
struct | multiplies_result< tensor4_basic< S1 >, tensor_basic< S2 > >
struct | multiplies_result< tensor4_basic< S1 >, tensor3_basic< S2 > >
struct | multiplies_result< tensor4_basic< S1 >, tensor4_basic< S2 > >
struct | multiplies
struct | generic_binary_traits< multiplies >
struct | divides_result
struct | divides_result< T1, T2, typename std::enable_if< is_rheolef_arithmetic< T1 >::value &&is_rheolef_arithmetic< T2 >::value >::type >
struct | divides_result< T1, T2, typename std::enable_if< is_undeterminated< T1 >::value &&is_undeterminated< T2 >::value >::type >
struct | divides_result< T, T, typename std::enable_if< ! is_rheolef_arithmetic< T >::value &&! is_undeterminated< T >::value >::type >
struct | divides_result< point_basic< T >, T >
struct | divides_result< tensor_basic< T >, T >
struct | divides_result< T, point_basic< T > >
struct | divides_result< T, tensor_basic< T > >
struct | divides_result< point_basic< T1 >, tensor_basic< T2 > >
struct | divides_result< tensor_basic< T1 >, point_basic< T2 > >
struct | divides_result< tensor3_basic< T >, T >
struct | divides_result< tensor4_basic< T >, T >
struct | divides_result< T, tensor3_basic< T > >
struct | divides_result< point_basic< T1 >, tensor3_basic< T2 > >
struct | divides_result< tensor_basic< T1 >, tensor3_basic< T2 > >
struct | divides_result< tensor3_basic< T1 >, point_basic< T2 > >
struct | divides_result< tensor3_basic< T1 >, tensor_basic< T2 > >
struct | divides_result< T, tensor4_basic< T > >
struct | divides_result< point_basic< T1 >, tensor4_basic< T2 > >
struct | divides_result< tensor_basic< T1 >, tensor4_basic< T2 > >
struct | divides_result< tensor3_basic< T1 >, tensor4_basic< T2 > >
struct | divides
struct | generic_binary_traits< divides >
struct | scalar_binary_traits
struct | generic_binary_traits< dot_ >
struct | ddot_result
struct | ddot_result< tensor_basic< A1 >, tensor_basic< A2 > >
struct | ddot_result< tensor4_basic< A1 >, tensor_basic< A2 > >
struct | ddot_result< tensor_basic< A1 >, tensor4_basic< A2 > >
struct | ddot_
struct | generic_binary_traits< ddot_ >
struct | dddot_result
struct | dddot_result< tensor3_basic< A1 >, tensor3_basic< A2 > >
struct | dddot_
struct | generic_binary_traits< dddot_ >
struct | binder_first
struct | generic_unary_traits< binder_first< BinaryFunction, A1 > >
struct | binder_second
struct | generic_unary_traits< binder_second< BinaryFunction, A2 > >
struct | swapper
struct | generic_binary_traits< swapper< BinaryFunction > >
struct | function_wrapper
struct | function_wrapper< Result(Arg)>
struct | function_wrapper< Result(Arg1, Arg2)>
class | field_concat_value
class | field_wdof_sliced
class | field_rdof_sliced_const
struct | is_field< field_basic< T, M > >
struct | function_traits< field_basic< T, M > >
struct | field_traits< field_basic< T, M > >
class | field_concat
struct | is_field
struct | is_field_wdof
struct | has_field_wdof_interface
struct | has_field_wdof_interface< FieldWdof, typename std::enable_if< is_field_wdof< FieldWdof >::value >::type >
struct | has_field_wdof_interface< FieldWdof, typename std::enable_if< is_field< FieldWdof >::value >::type >
struct | is_field_rdof
struct | has_field_rdof_interface
struct | has_field_rdof_interface< FieldRdof, typename std::enable_if< is_field_rdof< FieldRdof >::value >::type >
struct | has_field_rdof_interface< FieldRdof, typename std::enable_if< has_field_wdof_interface< FieldRdof >::value >::type >
struct | is_field_lazy
struct | has_field_lazy_interface
struct | has_field_lazy_interface< FieldLazy, typename std::enable_if< is_field_lazy< FieldLazy >::value >::type >
struct | has_field_lazy_interface< FieldLazy, typename std::enable_if< has_field_rdof_interface< FieldLazy >::value >::type >
struct | is_field_expr_v2_nonlinear_arg
struct | is_field_expr_v2_nonlinear_arg< Expr, typename std::enable_if< is_field_expr_v2_constant< Expr >::value >::type >
struct | is_field_expr_v2_nonlinear_arg< Expr, typename std::enable_if< has_field_rdof_interface< Expr >::value >::type >
struct | is_field_expr_affine_homogeneous
struct | is_field_expr_affine_homogeneous< Expr, typename std::enable_if< is_field_expr_v2_constant< Expr >::value >::type >
struct | is_field_expr_affine_homogeneous< Expr, typename std::enable_if< has_field_rdof_interface< Expr >::value >::type >
struct | is_field_true_function
struct | is_field_true_function< R(const point_basic< T > &)>
struct | is_field_true_function< R(*)(const point_basic< T > &)>
struct | is_field_functor

struct

is_field_functor< F, typename std::enable_if< std::conjunction< std::negation< has_field_lazy_interface< F > >, std::is_class< F >, is_functor< F >, std::disjunction< is_callable< F, Float(const point &) const >, is_callable< F, point(const point &) const >, is_callable< F, tensor(const point &) const >, is_callable< F, tensor3(const point &) const >, is_callable< F, tensor4(const point &) const > > >::value >::type >

struct | is_field_function
struct | is_field_function< F, typename std::enable_if< std::disjunction< is_field_true_function< F >, is_field_functor< F > >::value >::type >
struct | field_function_traits
struct | field_function_traits< F, typename std::enable_if< is_field_true_function< F >::value >::type >
struct | field_function_traits< F, typename std::enable_if< is_field_functor< F >::value >::type >
struct | is_field_expr_quadrature_arg
class | field_expr_quadrature_on_element
struct | is_field_expr_quadrature_arg< field_expr_quadrature_on_element< Expr > >
class | field_expr_quadrature_on_sides
struct | is_field_expr_quadrature_arg< field_expr_quadrature_on_sides< Expr > >
class | field_expr_quadrature_binary
struct | is_field_expr_quadrature_arg< field_expr_quadrature_binary< F, Expr1, Expr2 > >
class | field_expr_v2_nonlinear_node_unary
struct | is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_node_unary< F, Expr > >
struct | is_field_expr_affine_homogeneous< field_expr_v2_nonlinear_node_unary< F, Expr >, typename std::enable_if< field_expr_v2_nonlinear_node_unary< F, Expr >::is_affine_homogeneous::value >::type >
struct | field_expr_v2_nonlinear_terminal_wrapper_traits
class | field_expr_v2_nonlinear_terminal_function_base_rep
class | field_expr_v2_nonlinear_terminal_function_rep
class | field_expr_v2_nonlinear_terminal_function
struct | is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_terminal_function< F > >
struct | is_field_expr_v2_nonlinear_arg< F, typename std::enable_if< std::conjunction< std::negation< has_field_rdof_interface< F > >, is_field_function< F > >::value >::type >
struct | field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< std::conjunction< std::negation< has_field_rdof_interface< Expr > >, is_field_function< Expr > >::value >::type >
struct | field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< is_field_expr_v2_constant< Expr >::value >::type >
struct | normal_pseudo_function
class | field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >
struct | h_local_pseudo_function
class | field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >
struct | penalty_pseudo_function
class | field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >
class | field_expr_v2_nonlinear_terminal_field_rep
class | field_expr_v2_nonlinear_terminal_field
struct | is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_terminal_field< T, M, Diff > >
struct | is_field_expr_affine_homogeneous< field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none > >
struct | field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< has_field_rdof_interface< Expr >::value >::type >
class | field_expr_v2_nonlinear_terminal_field_dg_rep
class | field_expr_v2_nonlinear_terminal_field_dg
struct | is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_terminal_field_dg< T, M > >
class | field_expr_v2_nonlinear_terminal_field_o_characteristic_rep
class | field_expr_v2_nonlinear_terminal_field_o_characteristic
struct | is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_terminal_field_o_characteristic< T, M > >
class | field_expr_v2_variational_unary
struct | is_field_expr_v2_variational_arg< field_expr_v2_variational_unary< F, Expr > >
class | field_expr_v2_variational_binary
struct | is_field_expr_v2_variational_arg< field_expr_v2_variational_binary< F, Expr1, Expr2 > >
struct | is_field_expr_v2_variational_binary_plus_minus
struct | is_field_expr_v2_variational_binary_plus_minus< Expr1, Expr2, typename std::enable_if< is_field_expr_v2_variational_arg< Expr1 >::value &&is_field_expr_v2_variational_arg< Expr2 >::value >::type >
struct | nl_switch
struct | nl_switch< This, typename This::scalar_type >
struct | nl_switch< This, point_basic< typename This::scalar_type > >
struct | nl_switch< This, tensor_basic< typename This::scalar_type > >
struct | nl_switch< This, tensor3_basic< typename This::scalar_type > >
struct | nl_switch< This, tensor4_basic< typename This::scalar_type > >
class | field_expr_v2_variational_binary_binded
struct | is_field_expr_v2_variational_arg< field_expr_v2_variational_binary_binded< F, Expr1, Expr2 > >
struct | is_field_expr_v2_variational_binary_multiplies_divides_left
struct | is_field_expr_v2_variational_binary_multiplies_divides_left< Expr1, Expr2, typename std::enable_if< is_field_expr_v2_nonlinear_arg< Expr1 >::value &&! is_field_expr_v2_constant< Expr1 >::value &&is_field_expr_v2_variational_arg< Expr2 >::value >::type >
struct | is_field_expr_v2_variational_binary_multiplies_divides_right
struct | vf_tag_nonlinear
struct | dual_vf_tag
struct | dual_vf_tag< vf_tag_01 >
struct | dual_vf_tag< vf_tag_10 >
struct | dual_vf_tag< vf_tag_00 >
struct | dual_vf_tag< vf_tag_11 >
struct | uf_vf_tag
struct | uf_vf_tag< unary_plus, Tag >
struct | uf_vf_tag< negate, Tag >
struct | bf_vf_tag
struct | bf_vf_tag< plus, Tag, Tag >
struct | bf_vf_tag< minus, Tag, Tag >
struct | bf_vf_tag< multiplies, vf_tag_00, vf_tag_00 >
struct | bf_vf_tag< multiplies, vf_tag_00, vf_tag_01 >
struct | bf_vf_tag< multiplies, vf_tag_01, vf_tag_00 >
struct | bf_vf_tag< multiplies, vf_tag_00, vf_tag_10 >
struct | bf_vf_tag< multiplies, vf_tag_10, vf_tag_00 >
struct | bf_vf_tag< multiplies, vf_tag_01, vf_tag_10 >
struct | bf_vf_tag< multiplies, vf_tag_10, vf_tag_01 >
struct | bf_vf_tag< multiplies, vf_tag_00, vf_tag_11 >
struct | bf_vf_tag< multiplies, vf_tag_11, vf_tag_00 >
struct | is_field_expr_v2_variational_arg
struct | is_field_expr_v2_variational_arg< test_basic< T, M, VfTag > >
struct | is_field_expr_v2_variational_arg< test_component< T, M, VfTag > >
class | field_expr_v2_variational_grad
struct | is_field_expr_v2_variational_arg< field_expr_v2_variational_grad< Expr > >
class | field_expr_v2_variational_div
struct | is_field_expr_v2_variational_arg< field_expr_v2_variational_div< Expr > >
class | field_expr_v2_variational_curl
struct | is_field_expr_v2_variational_arg< field_expr_v2_variational_curl< Expr > >
class | field_expr_v2_variational_dg
struct | is_field_expr_v2_variational_arg< field_expr_v2_variational_dg< Expr > >
struct | field_traits
class | field_lazy_base
class | field_lazy_mult_form_rep
class | field_lazy_mult_form
struct | is_field_lazy< field_lazy_mult_form< FormExpr, FieldExpr > >
class | field_lazy_trans_mult_form_rep
class | field_lazy_trans_mult_form
struct | is_field_lazy< field_lazy_trans_mult_form< FormExpr, FieldExpr > >
class | field_lazy_unop
struct | is_field_lazy< field_lazy_unop< Unop, Expr > >
class | field_lazy_add
struct | is_field_lazy< field_lazy_add< Binop, Expr1, Expr2 > >
class | field_lazy_terminal_field
struct | is_field_lazy< field_lazy_terminal_field< T, M > >
class | field_lazy_terminal_integrate_rep
class | field_lazy_terminal_integrate
struct | is_field_lazy< field_lazy_terminal_integrate< Expr > >
class | field_lazy_terminal_integrate_band_rep
class | field_lazy_terminal_integrate_band
struct | is_field_lazy< field_lazy_terminal_integrate_band< Expr > >
class | field_lazy_terminal_interpolate_rep
class | field_lazy_terminal_interpolate
struct | is_field_lazy< field_lazy_terminal_interpolate< Expr > >
class | field_rdof_indirect_const
class | field_rdof_base
struct | field_wdof2rdof_traits
class | field_rdof_unary_iterator
class | field_rdof_unary
struct | is_field_rdof< field_rdof_unary< UnaryFunction, FieldRdof > >
struct | field_traits< field_rdof_unary< UnaryFunction, FieldRdof > >
class | field_wdof_indirect
class | field_wdof_base
class | field_indirect_const_iterator
class | field_indirect_iterator
class | field_indirect_base
struct | is_field_rdof< field_rdof_indirect_const< FieldRdof > >
struct | field_traits< field_rdof_indirect_const< FieldRdof > >
struct | is_field_wdof< field_wdof_indirect< FieldWdof > >
struct | is_field_function< field_wdof_indirect< FieldWdof > >
struct | field_traits< field_wdof_indirect< FieldWdof > >
struct | field_wdof2rdof_traits< field_wdof_indirect< FieldWdof > >
class | field_sliced_iterator
class | field_sliced_const_iterator
class | field_rdof_sliced_base
struct | is_field_wdof< field_rdof_sliced_const< FieldRdof > >
struct | field_traits< field_rdof_sliced_const< FieldRdof > >
struct | is_field_wdof< field_wdof_sliced< FieldWdof > >
struct | field_traits< field_wdof_sliced< FieldWdof > >
struct | field_wdof2rdof_traits< field_wdof_sliced< FieldWdof > >
class | form_concat_value
class | form_concat_line
struct | is_form_lazy
struct | vector_field_trans
class | form_concat
struct | is_form_expr_quadrature_arg
struct | is_form_expr_quadrature_on_side_arg
class | form_expr_quadrature_on_element
struct | is_form_expr_quadrature_arg< form_expr_quadrature_on_element< Expr > >
class | form_expr_quadrature_on_sides
struct | is_form_expr_quadrature_arg< form_expr_quadrature_on_sides< Expr > >
struct | is_form_expr_quadrature_on_side_arg< form_expr_quadrature_on_sides< Expr > >
class | form_expr_quadrature_unary
struct | is_form_expr_quadrature_arg< form_expr_quadrature_unary< F, Expr > >
class | form_expr_quadrature_binary
struct | is_form_expr_quadrature_arg< form_expr_quadrature_binary< F, Expr1, Expr2 > >
struct | is_form_expr_quadrature_binary_multiplies_divides_constant_left
struct | is_form_expr_quadrature_binary_multiplies_divides_constant_left< Expr1, Expr2, typename std::enable_if< is_rheolef_arithmetic< Expr1 >::value &&is_form_expr_quadrature_arg< Expr2 >::value >::type >
struct | is_form_expr_quadrature_binary_multiplies_divides_constant_right
struct | is_form_expr_v2_variational_arg
class | form_expr_v2_variational_unary
struct | is_form_expr_v2_variational_arg< form_expr_v2_variational_unary< F, Expr > >
class | form_expr_v2_variational_binary
struct | is_form_expr_v2_variational_arg< form_expr_v2_variational_binary< F, Expr1, Expr2 > >
class | form_expr_v2_variational_binary_field
struct | is_form_expr_v2_variational_arg< form_expr_v2_variational_binary_field< F, Expr1, Expr2 > >
struct | is_form_expr_v2_variational_binary_field
struct | is_form_expr_v2_variational_binary_field< Expr1, Expr2, typename std::enable_if< is_field_expr_v2_variational_arg< Expr1 >::value &&is_field_expr_v2_variational_arg< Expr2 >::value >::type >
class | form_expr_v2_variational_binary_binded
struct | is_form_expr_v2_variational_arg< form_expr_v2_variational_binary_binded< F, Expr1, Expr2 > >
struct | is_form_expr_v2_variational_binary_multiplies_divides_left
struct | is_form_expr_v2_variational_binary_multiplies_divides_left< Expr1, Expr2, typename std::enable_if< is_field_expr_v2_nonlinear_arg< Expr1 >::value &&! is_rheolef_arithmetic< Expr1 >::value &&is_form_expr_v2_variational_arg< Expr2 >::value >::type >
struct | is_form_expr_v2_variational_binary_multiplies_divides_right
class | form_lazy_unop
struct | is_form_lazy< form_lazy_unop< Unop, Expr > >
class | form_lazy_invert_rep
class | form_lazy_invert
struct | is_form_lazy< form_lazy_invert< Expr > >
class | form_lazy_transpose
struct | is_form_lazy< form_lazy_transpose< Expr > >
class | form_lazy_add
struct | is_form_lazy< form_lazy_add< Binop, Expr1, Expr2 > >
class | form_lazy_multiply_rep
class | form_lazy_multiply
struct | is_form_lazy< form_lazy_multiply< Expr1, Expr2 > >
class | form_lazy_base
class | form_lazy_terminal_integrate_rep
class | form_lazy_terminal_integrate
struct | is_form_lazy< form_lazy_terminal_integrate< Expr > >
class | form_lazy_terminal_integrate_band_rep
class | form_lazy_terminal_integrate_band
struct | is_form_lazy< form_lazy_terminal_integrate_band< Expr > >
struct | zero_dimension
struct | interpolate_internal_check
struct | interpolate_internal_check< T, M, Expr, T, std::true_type >
struct | interpolate_internal_check< T, M, Expr, point_basic< T >, std::true_type >
struct | interpolate_internal_check< T, M, Expr, tensor_basic< T >, std::true_type >
struct | interpolate_internal_check< T, M, Expr, undeterminated_basic< T >, Status >
struct | memorized_disarray
class | add_adapt< Problem, std::true_type >
class | add_adapt< Problem, std::false_type >
class | add_refresh< Problem, std::true_type >
class | add_refresh< Problem, std::false_type >
class | add_direction< Problem, std::true_type >
class | add_direction< Problem, std::false_type >
class | add_space_norm< Problem, std::true_type >
class | add_space_norm< Problem, std::false_type >
class | add_dual_space_norm< Problem, std::true_type >
class | add_dual_space_norm< Problem, std::false_type >
class | add_missing_damped_newton
class | add_missing_continuation
struct | pair_with_linear_algebra
class | test_component
class | test_component_rep

## Typedefs

template<size_t MIN, size_t MAX>
using | index_range = typename range_builder<MIN, MAX>::type
typedef std::pair< std::false_type, std::false_type > | vf_tag_00
typedef std::pair< std::false_type, std::true_type > | vf_tag_01
typedef std::pair< std::true_type, std::true_type > | vf_tag_11
typedef std::pair< std::true_type, std::false_type > | vf_tag_10

## Functions

template<class T1, class T2, class T3>
void | contract0_tensor3_vector (const Eigen::Tensor< T1, 3 > &a, const Eigen::Matrix< T2, Eigen::Dynamic, 1 > &b, Eigen::Matrix< T3, Eigen::Dynamic, Eigen::Dynamic > &c)
| _RHEOLEF_instanciation (Float, sequential) _RHEOLEF_instanciation(Float
template<class Map, class SetOp>
void | stash_set (Map &stash, typename Map::size_type dis_i, const typename Map::mapped_type &val, const SetOp &set_op, std::false_type)
template<class MultiMap, class U>
void | stash_set (MultiMap &stash, typename MultiMap::size_type dis_i, const U &val, const details::generic_set_op &, std::true_type)
template<class MultiMap, class U>
void | stash_set_plus_multi (MultiMap &stash, typename MultiMap::size_type dis_i, const U &val, const details::generic_set_plus_op &set_op, std::false_type)
template<class MultiMap, class U>
void | stash_set_plus_multi (MultiMap &stash, typename MultiMap::size_type dis_i, const U &val, const details::generic_set_plus_op &set_op, std::true_type)
template<class MultiMap, class U>
void | stash_set (MultiMap &stash, typename MultiMap::size_type dis_i, const U &val, const details::generic_set_plus_op &set_op, std::true_type)
| _RHEOLEF_generic_unary_syntax_functor (+, generic_unary_plus) _RHEOLEF_generic_unary_syntax_functor(-
generic_negate | _RHEOLEF_generic_binary_syntax_functor (+, generic_plus) _RHEOLEF_generic_binary_syntax_functor(-
generic_negate generic_minus _RHEOLEF_generic_binary_syntax_functor generic_multiplies | _RHEOLEF_generic_binary_syntax_functor (/, generic_divides) template< class BinaryFunction
template<class ForwardIterator, class InputIterator, class OpAssign>
void | assign_with_operator (ForwardIterator first, ForwardIterator last, InputIterator iter_rhs, OpAssign op_assign)
template<class SmallMatrix, class SmallVector, class Vector, class Vector2, class Size>
void | update (Vector &x, Size k, const SmallMatrix &h, const SmallVector &s, Vector2 &v)
template<class Real>
void | generate_plane_rotation (const Real &dx, const Real &dy, Real &cs, Real &sn)
template<class Real>
void | apply_plane_rotation (Real &dx, Real &dy, const Real &cs, const Real &sn)
| _RHEOLEF_generic_set_xxx_op (generic_set_op,=) _RHEOLEF_generic_set_xxx_op(generic_set_plus_op
template<class T, class Function>
std::enable_if< is_scalar< typenamefunction_traits< Function >::result_type >::value, void >::type | compute_dof (const basis_rep< T > &b, reference_element hat_K, const Function &f, Eigen::Matrix< T, Eigen::Dynamic, 1 > &dof)
template<class T, class Function>
std::enable_if< is_point< typenamefunction_traits< Function >::result_type >::value, void >::type | compute_dof (const basis_rep< T > &b, reference_element hat_K, const Function &f, Eigen::Matrix< T, Eigen::Dynamic, 1 > &dof)
template<class Basis, class T, class Value>
void | basis_on_pointset_evaluate (const Basis &b, const reference_element &hat_K, const Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 > &hat_x, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &vdm)
template<class Basis, class T, class Value>
void | basis_on_pointset_grad_evaluate (const Basis &b, const reference_element &hat_K, const Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 > &hat_x, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &vdm_grad)
template<class Basis, class T, class Value>
void | basis_on_pointset_evaluate_on_side (const Basis &b, const reference_element &tilde_K, const side_information_type &sid, const Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 > &hat_x, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &vdm)
template<class Basis>
void | put (const Basis &b, ostream &os, reference_element hat_K)
| _RHEOLEF_class_specialization (T, _scalar_val) _RHEOLEF_class_specialization(point_basic< T >
_vector_val | _RHEOLEF_class_specialization (tensor_basic< T >, _tensor_val) _RHEOLEF_class_specialization(tensor3_basic< T >
_vector_val _tensor3_val | _RHEOLEF_class_specialization (tensor4_basic< T >, _tensor4_val) template< class T
| _RHEOLEF_class_specialization (T, _sid_scalar_val) _RHEOLEF_class_specialization(point_basic< T >
_sid_vector_val | _RHEOLEF_class_specialization (tensor_basic< T >, _sid_tensor_val) _RHEOLEF_class_specialization(tensor3_basic< T >
template<class T, class M>
void | interpolate_pass1_symbolic (const geo_basic< T, M > &omega, const disarray< point_basic< T >, M > &x, const disarray< geo_element::size_type, M > &ix2dis_ie, disarray< index_set, M > &ie2dis_ix, disarray< point_basic< T >, M > &hat_y)
template<class T, class M>
void | integrate_pass1_symbolic (const space_basic< T, M > &Xh, const field_basic< T, M > &dh, const piola_on_pointset< T > &pops, disarray< index_set, M > &ie2dis_ix, disarray< point_basic< T >, M > &hat_y, disarray< point_basic< T >, M > &yq)
template<class Problem>
int | continuation_solve (const Problem &F, typename Problem::value_type &uh, odiststream *p_err, const continuation_option &opts)
template<class Problem>
void | continuation_internal (Problem &F, typename Problem::value_type &uh, odiststream *p_out, odiststream *p_err, const continuation_option &opts)
template<class Solver>
Solver::float_type | step_adjust (Solver &F, size_t n, typename Solver::float_type delta_parameter_prev, const typename Solver::value_type &uh_prev, const typename Solver::value_type &duh_dparameter, const typename Solver::float_type &duh_dparameter_sign, const continuation_option &opts, odiststream *p_err, typename Solver::value_type &uh_guess)

_RHEOLEF_generic_unary_scalar (cos) _RHEOLEF_generic_unary_scalar(sin) _RHEOLEF_generic_unary_scalar(tan) _RHEOLEF_generic_unary_scalar(acos) _RHEOLEF_generic_unary_scalar(asin) _RHEOLEF_generic_unary_scalar(atan) _RHEOLEF_generic_unary_scalar(cosh) _RHEOLEF_generic_unary_scalar(sinh) _RHEOLEF_generic_unary_scalar(tanh) _RHEOLEF_generic_unary_scalar(exp) _RHEOLEF_generic_unary_scalar(log) _RHEOLEF_generic_unary_scalar(log10) _RHEOLEF_generic_unary_scalar(sqrt) _RHEOLEF_generic_unary_scalar(abs) _RHEOLEF_generic_unary_scalar(fabs) _RHEOLEF_generic_unary_scalar(floor) _RHEOLEF_generic_unary_scalar(ceil) _RHEOLEF_generic_unary_scalar(sqr) struct tr_

| _RHEOLEF_generic_binary_scalar (atan2) _RHEOLEF_generic_binary_scalar(pow) _RHEOLEF_generic_binary_scalar(fmod) _RHEOLEF_generic_binary_scalar(min) _RHEOLEF_generic_binary_scalar(max) struct dot_
template<class Function>
Function | function_wrap (Function f)
template<class Result, class Arg>
std::pointer_to_unary_function< Arg, Result > | function_wrap (Result(*f)(Arg))
template<class Result, class Arg1, class Arg2>
std::pointer_to_binary_function< Arg1, Arg2, Result > | function_wrap (Result(*f)(Arg1, Arg2))
template<class T, class M>
const geo_element & | global_get_side (const geo_basic< T, M > &omega_L, const geo_element &L, const side_information_type &sid)
template<class T, class M, class Value>
void | interpolate_pass2_valued (const field_basic< T, M > &uh, const disarray< point_basic< T >, M > &x, const disarray< index_set, M > &ie2dis_ix, const disarray< point_basic< T >, M > &hat_y, disarray< Value, M > &ux)
template<class T, class M, class Expr, class Result>
void | field_expr_v2_value_assembly (const geo_basic< T, M > &omega, const Expr &expr0, const integrate_option &iopt, Result &result)
template<class T>
void | compute_idof_S2idof_K (const basis_basic< T > &b, const reference_element &hat_K, std::array< std::vector< size_t >, reference_element::max_side_by_variant > &idof_S2idof_K, std::array< size_t, reference_element::max_side_by_variant > &ndof_S, size_t &ndof_K)
template<class FieldWdof, class FieldRdof>
std::enable_if< details::has_field_wdof_interface< FieldWdof >::value &&details::has_field_rdof_interface< FieldRdof >::value, FieldWdof & >::type | operator+= (FieldWdof &wdof, const FieldRdof &rdof)
template<class FieldWdof, class FieldRdof>
std::enable_if< details::has_field_wdof_interface< FieldWdof >::value &&details::has_field_rdof_interface< FieldRdof >::value, FieldWdof & >::type | operator-= (FieldWdof &wdof, const FieldRdof &rdof)
template<class FieldWdof, class FieldLazy>
std::enable_if< details::has_field_wdof_interface< FieldWdof >::value &&details::has_field_lazy_interface< FieldLazy >::value &&!details::has_field_rdof_interface< FieldLazy >::value, FieldWdof & >::type | operator+= (FieldWdof &wdof, const FieldLazy &lazy)
template<class FieldWdof, class FieldLazy>
std::enable_if< details::has_field_wdof_interface< FieldWdof >::value &&details::has_field_lazy_interface< FieldLazy >::value &&!details::has_field_rdof_interface< FieldLazy >::value, FieldWdof & >::type | operator-= (FieldWdof &wdof, const FieldLazy &lazy)
template<class FieldWdof, class FieldLazy, class SetPlusOp>
std::enable_if< has_field_lazy_interface< FieldLazy >::value &&has_field_wdof_interface< FieldWdof >::value, FieldWdof & >::type | convert_lazy2wdof (const FieldLazy &expr0, const SetPlusOp &my_set_plus_op, FieldWdof &uh)
template<class T>
T | norm_max (Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<class T>
bool | check_is_symmetric (Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m, const T &tol_m_max)
template<class T>
void | local_lump (Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<class T>
void | local_invert (Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m, bool is_diag)
template<class T, class M, class WeightFunction>
bool | form_named_init (form_basic< T, M > &a, const geo_basic< T, M > &dom, const std::string &name, bool has_weight, WeightFunction w, const quadrature_option &qopt)
template<class T, class M>
bool | point_belongs_to_e (const geo_element &K, const disarray< point_basic< T >, M > &node, const point_basic< T > &x)
template<class T, class M>
bool | point_belongs_to_t (const geo_element &K, const disarray< point_basic< T >, M > &node, const point_basic< T > &x)
template<class T, class M>
bool | point_belongs_to_q (const geo_element &K, const disarray< point_basic< T >, M > &node, const point_basic< T > &x)
template<class T, class M>
bool | point_belongs_to_T (const geo_element &K, const disarray< point_basic< T >, M > &node, const point_basic< T > &x)
template<class T, class M>
bool | point_belongs_to_H (const geo_element &K, const disarray< point_basic< T >, M > &node, const point_basic< T > &x)
template<class T, class M>
bool | point_belongs_to_P (const geo_element &K, const disarray< point_basic< T >, M > &node, const point_basic< T > &x)
template<class T, class M>
bool | contains (const geo_element &K, const disarray< point_basic< T >, M > &node, const point_basic< T > &x)
template<class T, class M>
integrate_option | expr_quadrature_init_iopt (const geo_basic< T, M > &omega_K, const space_basic< T, M > &X, size_t n_derivative, const integrate_option &iopt)
template<class T, class M>
integrate_option | expr_quadrature_init_iopt (const geo_basic< T, M > &omega_K, const space_basic< T, M > &X, const space_basic< T, M > &Y, size_t n_derivative, const integrate_option &iopt)
template<class T>
quadrature< T > | expr_quadrature_init_quad (const integrate_option &iopt)
template<class T, class M, class Expr>
T | integrate_internal (const geo_basic< T, M > &omega, const rheolef::field_nonlinear_expr< Expr > &f, const quadrature_option &qopt, const T &)
template<class T, class M, class Expr>
rheolef::field_nonlinear_expr< Expr >::scalar_type | integrate_numeric (const geo_basic< T, M > &omega, const rheolef::field_nonlinear_expr< Expr > &f, const quadrature_option &qopt)
template<class T, class M, class Value>
void | interpolate_pass3_dof (const disarray< Value, M > &ux2, field_basic< T, M > &u2h)
template<class T, class M, class Value>
void | interpolate_on_a_different_mesh (const field_basic< T, M > &u1h, const disarray< point_basic< T >, M > &x2, const disarray< geo_element::size_type, M > &ix2dis_ie, disarray< Value, M > &ux2)
template<class T, class M, class Expr, class Result>
field_basic< T, M > | interpolate_generic (const space_basic< T, M > &Xh, const Expr &expr0)
template<class T, class M, class Expr, class Result>
field_basic< T, M > | interpolate_internal (const space_basic< T, M > &Xh, const Expr &expr)
template<class T>
void | reset (T &x)
template<class T>
void | reset (std::valarray< T > &x)
template<class T1, class T2>
void | reset (pair_with_linear_algebra< T1, T2 > &x)
template<class T>
T | max_abs (const T &x)
template<class T>
T | max_abs (const field_basic< T > &x)
template<class T>
field_basic< T >::float_type | max_abs (const std::valarray< field_basic< T > > &x)
template<class T>
size_t | get_unknown (const T &x)
template<class T>
size_t | unknown_size (const field_basic< T > &x)
template<class T>
size_t | unknown_size (const std::valarray< field_basic< T > > &x)
template<class T>
T | get_unknown (const T &x)
template<class T>
T | get_unknown (const T &x, const distributor &)
template<class T>
vec< T > | get_unknown (const field_basic< T > &x)
template<class T>
vec< T > | get_unknown (const field_basic< T > &x, const distributor &)
template<class T>
vec< T > | get_unknown (const std::valarray< field_basic< T > > &x, const distributor &ownership)
template<class T>
vec< T > | get_unknown (const std::valarray< field_basic< T > > &x)
template<class T>
void | set_unknown (T &x, const T &value)
template<class T>
void | set_unknown (field_basic< T > &x, const vec< T > &value)
template<class T>
void | set_unknown (std::valarray< field_basic< T > > &x, const vec< T > &value)
template<class T>
T | minmod (const T &a, const T &b)
template<class T>
T | minmod_tvb (const T &yield_a, const T &a, const T &b)
| _RHEOLEF_has_inherited_member_macro (adapt) template< class Problem
| _RHEOLEF_has_inherited_member_macro (refresh) template< class Problem
| _RHEOLEF_has_inherited_member_macro (direction) template< class Problem
| _RHEOLEF_has_inherited_member_macro (space_norm) template< class Problem
| _RHEOLEF_has_inherited_member_macro (dual_space_norm) template< class Problem
template<class T1, class T2>
pair_with_linear_algebra< T1, T2 > | operator- (const pair_with_linear_algebra< T1, T2 > &x)
template<class T0, class T1, class T2>
pair_with_linear_algebra< T1, T2 > | operator* (const T0 &k, const pair_with_linear_algebra< T1, T2 > &x)
template<class T1, class T2>
pair_with_linear_algebra< T1, T2 > | operator+ (const pair_with_linear_algebra< T1, T2 > &x, const pair_with_linear_algebra< T1, T2 > &y)
template<class T1, class T2>
pair_with_linear_algebra< T1, T2 > | operator- (const pair_with_linear_algebra< T1, T2 > &x, const pair_with_linear_algebra< T1, T2 > &y)
template<class T, class M, class Geo, class Function>
field_basic< T, M > | riesz_function_internal (const space_basic< T, M > &Xh, const Function &f, const quadrature_option &qopt, const Geo &dom, std::false_type)
template<class T, class M, class Geo, class Function>
field_basic< T, M > | riesz_function_internal (const space_basic< T, M > &Xh, const Function &f, const quadrature_option &qopt, const Geo &dom, std::true_type)
template<class T, class M, class Geo, class Function>
field_basic< T, M > | riesz_tag2 (const space_basic< T, M > &Xh, const Function &f, const quadrature_option &qopt, const Geo &dom, const T &)
template<class T, class M, class Geo, class Function>
field_basic< T, M > | riesz_tag2 (const space_basic< T, M > &Xh, const Function &f, const quadrature_option &qopt, const Geo &dom, const point_basic< T > &)
template<class T, class M, class Geo, class Function>
field_basic< T, M > | riesz_tag2 (const space_basic< T, M > &Xh, const Function &f, const quadrature_option &qopt, const Geo &dom, const undeterminated_basic< T > &)
template<class T, class M, class Geo, class Function>
std::enable_if< is_field_function< Function >::value, field_basic< T, M > >::type | riesz_tag (const space_basic< T, M > &Xh, const Function &f, const quadrature_option &qopt, const Geo &dom, std::false_type)
template<class T, class M, class Geo, class Function>
std::enable_if<!is_field_function< Function >::value, field_basic< T, M > >::type | riesz_tag (const space_basic< T, M > &Xh, const Function &f, const quadrature_option &qopt, const Geo &dom, std::false_type)
template<class T, class M, class Geo, class Constant>
field_basic< T, M > | riesz_tag (const space_basic< T, M > &Xh, const Constant &value, const quadrature_option &qopt, const Geo &dom, std::true_type)

## Variables

rheolef::details::is_vec | dot
class rheolef::details::field_expr_v2_nonlinear_node_unary | compose

## Typedef Documentation

## index_range

template<size_t MIN, size_t MAX>

using index_range = typename range_builder<MIN, MAX>::type

Definition at line 133 of file field_expr_utilities.h.

## vf_tag_00

typedef std::pair< std::false_type, std::false_type > vf_tag_00

Definition at line 50 of file field_expr_variational_tag.h.

## vf_tag_01

typedef std::pair< std::false_type, std::true_type > vf_tag_01

Definition at line 51 of file field_expr_variational_tag.h.

## vf_tag_11

typedef std::pair< std::true_type, std::true_type > vf_tag_11

Definition at line 52 of file field_expr_variational_tag.h.

## vf_tag_10

typedef std::pair< std::true_type, std::false_type > vf_tag_10

Definition at line 53 of file field_expr_variational_tag.h.

## Function Documentation

## contract0_tensor3_vector()

template<class T1, class T2, class T3>

void contract0_tensor3_vector | ( | const Eigen::Tensor< T1, 3 > & | a,
|  | const Eigen::Matrix< T2, Eigen::Dynamic, 1 > & | b,
|  | Eigen::Matrix< T3, Eigen::Dynamic, Eigen::Dynamic > & | c )

Definition at line 44 of file compiler_eigen.h.

## _RHEOLEF_instanciation()

_RHEOLEF_instanciation | ( | Float | ,
|  | sequential | )

## stash_set() [1/3]

template<class Map, class SetOp>

void stash_set | ( | Map & | stash,
|  | typename Map::size_type | dis_i,
|  | const typename Map::mapped_type & | val,
|  | const SetOp & | set_op,
|  | std::false_type | )

Definition at line 90 of file disarray_mpi.icc.

## stash_set() [2/3]

template<class MultiMap, class U>

void stash_set | ( | MultiMap & | stash,
|  | typename MultiMap::size_type | dis_i,
|  | const U & | val,
|  | const details::generic_set_op & | ,
|  | std::true_type | )

Definition at line 100 of file disarray_mpi.icc.

## stash_set_plus_multi() [1/2]

template<class MultiMap, class U>

void stash_set_plus_multi | ( | MultiMap & | stash,
|  | typename MultiMap::size_type | dis_i,
|  | const U & | val,
|  | const details::generic_set_plus_op & | set_op,
|  | std::false_type | )

Definition at line 116 of file disarray_mpi.icc.

## stash_set_plus_multi() [2/2]

template<class MultiMap, class U>

void stash_set_plus_multi | ( | MultiMap & | stash,
|  | typename MultiMap::size_type | dis_i,
|  | const U & | val,
|  | const details::generic_set_plus_op & | set_op,
|  | std::true_type | )

Definition at line 125 of file disarray_mpi.icc.

## stash_set() [3/3]

template<class MultiMap, class U>

void stash_set | ( | MultiMap & | stash,
|  | typename MultiMap::size_type | dis_i,
|  | const U & | val,
|  | const details::generic_set_plus_op & | set_op,
|  | std::true_type | )

Definition at line 136 of file disarray_mpi.icc.

## _RHEOLEF_generic_unary_syntax_functor()

_RHEOLEF_generic_unary_syntax_functor | ( | + | ,
|  | generic_unary_plus | )

## _RHEOLEF_generic_binary_syntax_functor() [1/2]

generic_negate _RHEOLEF_generic_binary_syntax_functor | ( | + | ,
|  | generic_plus | )

## _RHEOLEF_generic_binary_syntax_functor() [2/2]

generic_negate generic_minus _RHEOLEF_generic_binary_syntax_functor generic_multiplies _RHEOLEF_generic_binary_syntax_functor | ( | / | ,
|  | generic_divides | )

## assign_with_operator()

template<class ForwardIterator, class InputIterator, class OpAssign>

void assign_with_operator | ( | ForwardIterator | first,
|  | ForwardIterator | last,
|  | InputIterator | iter_rhs,
|  | OpAssign | op_assign )

Definition at line 137 of file expr_utilities.h.

## update()

template<class SmallMatrix, class SmallVector, class Vector, class Vector2, class Size>

void update | ( | Vector & | x,
|  | Size | k,
|  | const SmallMatrix & | h,
|  | const SmallVector & | s,
|  | Vector2 & | v )

Definition at line 132 of file gmres.h.

## generate_plane_rotation()

template<class Real>

void generate_plane_rotation | ( | const Real & | dx,
|  | const Real & | dy,
|  | Real & | cs,
|  | Real & | sn )

Definition at line 145 of file gmres.h.

## apply_plane_rotation()

template<class Real>

void apply_plane_rotation | ( | Real & | dx,
|  | Real & | dy,
|  | const Real & | cs,
|  | const Real & | sn )

Definition at line 160 of file gmres.h.

## _RHEOLEF_generic_set_xxx_op()

_RHEOLEF_generic_set_xxx_op | ( | generic_set_op |  | ) |

## compute_dof() [1/2]

template<class T, class Function>

std::enable_if< is_scalar< typenamefunction_traits< Function >::result_type >::value, void >::type compute_dof | ( | const basis_rep< T > & | b,
|  | reference_element | hat_K,
|  | const Function & | f,
|  | Eigen::Matrix< T, Eigen::Dynamic, 1 > & | dof )

Definition at line 520 of file basis.h.

## compute_dof() [2/2]

template<class T, class Function>

std::enable_if< is_point< typenamefunction_traits< Function >::result_type >::value, void >::type compute_dof | ( | const basis_rep< T > & | b,
|  | reference_element | hat_K,
|  | const Function & | f,
|  | Eigen::Matrix< T, Eigen::Dynamic, 1 > & | dof )

Definition at line 543 of file basis.h.

## basis_on_pointset_evaluate()

template<class Basis, class T, class Value>

void basis_on_pointset_evaluate | ( | const Basis & | b,
|  | const reference_element & | hat_K,
|  | const Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 > & | hat_x,
|  | Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > & | vdm )

Definition at line 31 of file basis_on_pointset_evaluate.icc.

## basis_on_pointset_grad_evaluate()

template<class Basis, class T, class Value>

void basis_on_pointset_grad_evaluate | ( | const Basis & | b,
|  | const reference_element & | hat_K,
|  | const Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 > & | hat_x,
|  | Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > & | vdm_grad )

Definition at line 48 of file basis_on_pointset_evaluate.icc.

## basis_on_pointset_evaluate_on_side()

template<class Basis, class T, class Value>

void basis_on_pointset_evaluate_on_side | ( | const Basis & | b,
|  | const reference_element & | tilde_K,
|  | const side_information_type & | sid,
|  | const Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 > & | hat_x,
|  | Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > & | vdm )

Definition at line 65 of file basis_on_pointset_evaluate.icc.

## put()

template<class Basis>

void put | ( | const Basis & | b,
|  | ostream & | os,
|  | reference_element | hat_K )

Definition at line 32 of file basis_visu_gnuplot.icc.

## _RHEOLEF_class_specialization() [1/5]

_RHEOLEF_class_specialization | ( | T | ,
|  | _scalar_val | )

## _RHEOLEF_class_specialization() [2/5]

_vector_val _RHEOLEF_class_specialization | ( | tensor_basic< T > | ,
|  | _tensor_val | )

## _RHEOLEF_class_specialization() [3/5]

_vector_val _tensor3_val _RHEOLEF_class_specialization | ( | tensor4_basic< T > | ,
|  | _tensor4_val | )

## _RHEOLEF_class_specialization() [4/5]

_RHEOLEF_class_specialization | ( | T | ,
|  | _sid_scalar_val | )

## _RHEOLEF_class_specialization() [5/5]

_sid_vector_val _RHEOLEF_class_specialization | ( | tensor_basic< T > | ,
|  | _sid_tensor_val | )

## interpolate_pass1_symbolic()

template<class T, class M>

void interpolate_pass1_symbolic | ( | const geo_basic< T, M > & | omega,
|  | const disarray< point_basic< T >, M > & | x,
|  | const disarray< geo_element::size_type, M > & | ix2dis_ie,
|  | disarray< index_set, M > & | ie2dis_ix,
|  | disarray< point_basic< T >, M > & | hat_y )

Definition at line 44 of file interpolate.cc.

## integrate_pass1_symbolic()

template<class T, class M>

void integrate_pass1_symbolic | ( | const space_basic< T, M > & | Xh,
|  | const field_basic< T, M > & | dh,
|  | const piola_on_pointset< T > & | pops,
|  | disarray< index_set, M > & | ie2dis_ix,
|  | disarray< point_basic< T >, M > & | hat_y,
|  | disarray< point_basic< T >, M > & | yq )

Definition at line 67 of file characteristic.cc.

## continuation_solve()

template<class Problem>

int continuation_solve | ( | const Problem & | F,
|  | typename Problem::value_type & | uh,
|  | odiststream * | p_err,
|  | const continuation_option & | opts )

Definition at line 126 of file continuation.h.

## continuation_internal()

template<class Problem>

void continuation_internal | ( | Problem & | F,
|  | typename Problem::value_type & | uh,
|  | odiststream * | p_out,
|  | odiststream * | p_err,
|  | const continuation_option & | opts )

Definition at line 143 of file continuation.h.

## step_adjust()

template<class Solver>

Solver::float_type step_adjust | ( | Solver & | F,
|  | size_t | n,
|  | typename Solver::float_type | delta_parameter_prev,
|  | const typename Solver::value_type & | uh_prev,
|  | const typename Solver::value_type & | duh_dparameter,
|  | const typename Solver::float_type & | duh_dparameter_sign,
|  | const continuation_option & | opts,
|  | odiststream * | p_err,
|  | typename Solver::value_type & | uh_guess )

Definition at line 28 of file continuation_step.h.

## _RHEOLEF_generic_unary_scalar()

_RHEOLEF_generic_unary_scalar | ( | cos |  | ) |

Definition at line 279 of file expression.h.

## _RHEOLEF_generic_binary_scalar()

_RHEOLEF_generic_binary_scalar | ( | atan2 |  | ) |

Definition at line 1439 of file expression.h.

## function_wrap() [1/3]

template<class Function>

Function function_wrap | ( | Function | f | ) |

Definition at line 1947 of file expression.h.

## function_wrap() [2/3]

template<class Result, class Arg>

std::pointer_to_unary_function< Arg, Result > function_wrap | ( | Result(* | f )(Arg) | ) |

Definition at line 1954 of file expression.h.

## function_wrap() [3/3]

template<class Result, class Arg1, class Arg2>

std::pointer_to_binary_function< Arg1, Arg2, Result > function_wrap | ( | Result(* | f )(Arg1, Arg2) | ) |

Definition at line 1961 of file expression.h.

## global_get_side()

template<class T, class M>

const geo_element & global_get_side | ( | const geo_basic< T, M > & | omega_L,
|  | const geo_element & | L,
|  | const side_information_type & | sid )

Definition at line 75 of file field_expr_terminal.cc.

## interpolate_pass2_valued()

template<class T, class M, class Value>

void interpolate_pass2_valued | ( | const field_basic< T, M > & | uh,
|  | const disarray< point_basic< T >, M > & | x,
|  | const disarray< index_set, M > & | ie2dis_ix,
|  | const disarray< point_basic< T >, M > & | hat_y,
|  | disarray< Value, M > & | ux )

Definition at line 122 of file interpolate.cc.

## field_expr_v2_value_assembly()

template<class T, class M, class Expr, class Result>

void field_expr_v2_value_assembly | ( | const geo_basic< T, M > & | omega,
|  | const Expr & | expr0,
|  | const integrate_option & | iopt,
|  | Result & | result )

Definition at line 55 of file field_expr_value_assembly.h.

## compute_idof_S2idof_K()

template<class T>

void compute_idof_S2idof_K | ( | const basis_basic< T > & | b,
|  | const reference_element & | hat_K,
|  | std::array< std::vector< size_t >, reference_element::max_side_by_variant > & | idof_S2idof_K,
|  | std::array< size_t, reference_element::max_side_by_variant > & | ndof_S,
|  | size_t & | ndof_K )

Definition at line 366 of file field_lazy_terminal.h.

## operator+=() [1/2]

template<class FieldWdof, class FieldRdof>

std::enable_if< details::has_field_wdof_interface< FieldWdof >::value &&details::has_field_rdof_interface< FieldRdof >::value, FieldWdof & >::type operator+= | ( | FieldWdof & | wdof,
|  | const FieldRdof & | rdof )

Definition at line 99 of file field_wdof.icc.

## operator-=() [1/2]

template<class FieldWdof, class FieldRdof>

std::enable_if< details::has_field_wdof_interface< FieldWdof >::value &&details::has_field_rdof_interface< FieldRdof >::value, FieldWdof & >::type operator-= | ( | FieldWdof & | wdof,
|  | const FieldRdof & | rdof )

Definition at line 114 of file field_wdof.icc.

## operator+=() [2/2]

template<class FieldWdof, class FieldLazy>

std::enable_if< details::has_field_wdof_interface< FieldWdof >::value &&details::has_field_lazy_interface< FieldLazy >::value &&!details::has_field_rdof_interface< FieldLazy >::value, FieldWdof & >::type operator+= | ( | FieldWdof & | wdof,
|  | const FieldLazy & | lazy )

Definition at line 130 of file field_wdof.icc.

## operator-=() [2/2]

template<class FieldWdof, class FieldLazy>

std::enable_if< details::has_field_wdof_interface< FieldWdof >::value &&details::has_field_lazy_interface< FieldLazy >::value &&!details::has_field_rdof_interface< FieldLazy >::value, FieldWdof & >::type operator-= | ( | FieldWdof & | wdof,
|  | const FieldLazy & | lazy )

Definition at line 145 of file field_wdof.icc.

## convert_lazy2wdof()

template<class FieldWdof, class FieldLazy, class SetPlusOp>

std::enable_if< has_field_lazy_interface< FieldLazy >::value &&has_field_wdof_interface< FieldWdof >::value, FieldWdof & >::type convert_lazy2wdof | ( | const FieldLazy & | expr0,
|  | const SetPlusOp & | my_set_plus_op,
|  | FieldWdof & | uh )

Definition at line 59 of file field_wdof_convert.h.

## norm_max()

template<class T>

T norm_max | ( | Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & | m | ) |

Definition at line 33 of file form_vf_assembly.cc.

## check_is_symmetric()

template<class T>

bool check_is_symmetric | ( | Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & | m,
|  | const T & | tol_m_max )

Definition at line 46 of file form_vf_assembly.cc.

## local_lump()

template<class T>

void local_lump | ( | Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & | m | ) |

Definition at line 61 of file form_vf_assembly.cc.

## local_invert()

template<class T>

void local_invert | ( | Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & | m,
|  | bool | is_diag )

Definition at line 77 of file form_vf_assembly.cc.

## form_named_init()

template<class T, class M, class WeightFunction>

bool form_named_init | ( | form_basic< T, M > & | a,
|  | const geo_basic< T, M > & | dom,
|  | const std::string & | name,
|  | bool | has_weight,
|  | WeightFunction | w,
|  | const quadrature_option & | qopt )

Definition at line 47 of file form_weighted.h.

## point_belongs_to_e()

template<class T, class M>

bool point_belongs_to_e | ( | const geo_element & | K,
|  | const disarray< point_basic< T >, M > & | node,
|  | const point_basic< T > & | x )

Definition at line 31 of file geo_element_contains.cc.

## point_belongs_to_t()

template<class T, class M>

bool point_belongs_to_t | ( | const geo_element & | K,
|  | const disarray< point_basic< T >, M > & | node,
|  | const point_basic< T > & | x )

Definition at line 42 of file geo_element_contains.cc.

## point_belongs_to_q()

template<class T, class M>

bool point_belongs_to_q | ( | const geo_element & | K,
|  | const disarray< point_basic< T >, M > & | node,
|  | const point_basic< T > & | x )

Definition at line 58 of file geo_element_contains.cc.

## point_belongs_to_T()

template<class T, class M>

bool point_belongs_to_T | ( | const geo_element & | K,
|  | const disarray< point_basic< T >, M > & | node,
|  | const point_basic< T > & | x )

Definition at line 76 of file geo_element_contains.cc.

## point_belongs_to_H()

template<class T, class M>

bool point_belongs_to_H | ( | const geo_element & | K,
|  | const disarray< point_basic< T >, M > & | node,
|  | const point_basic< T > & | x )

Definition at line 94 of file geo_element_contains.cc.

## point_belongs_to_P()

template<class T, class M>

bool point_belongs_to_P | ( | const geo_element & | K,
|  | const disarray< point_basic< T >, M > & | node,
|  | const point_basic< T > & | x )

Definition at line 120 of file geo_element_contains.cc.

## contains()

template<class T, class M>

bool contains | ( | const geo_element & | K,
|  | const disarray< point_basic< T >, M > & | node,
|  | const point_basic< T > & | x )

Definition at line 144 of file geo_element_contains.cc.

## expr_quadrature_init_iopt() [1/2]

template<class T, class M>

integrate_option expr_quadrature_init_iopt | ( | const geo_basic< T, M > & | omega_K,
|  | const space_basic< T, M > & | X,
|  | size_t | n_derivative,
|  | const integrate_option & | iopt )

Definition at line 36 of file init_expr_quadrature.h.

## expr_quadrature_init_iopt() [2/2]

template<class T, class M>

integrate_option expr_quadrature_init_iopt | ( | const geo_basic< T, M > & | omega_K,
|  | const space_basic< T, M > & | X,
|  | const space_basic< T, M > & | Y,
|  | size_t | n_derivative,
|  | const integrate_option & | iopt )

Definition at line 53 of file init_expr_quadrature.h.

## expr_quadrature_init_quad()

template<class T>

quadrature< T > expr_quadrature_init_quad | ( | const integrate_option & | iopt | ) |

Definition at line 80 of file init_expr_quadrature.h.

## integrate_internal()

template<class T, class M, class Expr>

T integrate_internal | ( | const geo_basic< T, M > & | omega,
|  | const rheolef::field_nonlinear_expr< Expr > & | f,
|  | const quadrature_option & | qopt,
|  | const T & | )

Definition at line 33 of file integrate_numeric.icc.

## integrate_numeric()

template<class T, class M, class Expr>

rheolef::field_nonlinear_expr< Expr >::scalar_type integrate_numeric | ( | const geo_basic< T, M > & | omega,
|  | const rheolef::field_nonlinear_expr< Expr > & | f,
|  | const quadrature_option & | qopt )

Definition at line 45 of file integrate_numeric.icc.

## interpolate_pass3_dof()

template<class T, class M, class Value>

void interpolate_pass3_dof | ( | const disarray< Value, M > & | ux2,
|  | field_basic< T, M > & | u2h )

Definition at line 176 of file interpolate.cc.

## interpolate_on_a_different_mesh()

template<class T, class M, class Value>

void interpolate_on_a_different_mesh | ( | const field_basic< T, M > & | u1h,
|  | const disarray< point_basic< T >, M > & | x2,
|  | const disarray< geo_element::size_type, M > & | ix2dis_ie,
|  | disarray< Value, M > & | ux2 )

Definition at line 210 of file interpolate.cc.

## interpolate_generic()

template<class T, class M, class Expr, class Result>

field_basic< T, M > interpolate_generic | ( | const space_basic< T, M > & | Xh,
|  | const Expr & | expr0 )

Definition at line 123 of file interpolate.h.

## interpolate_internal()

template<class T, class M, class Expr, class Result>

field_basic< T, M > interpolate_internal | ( | const space_basic< T, M > & | Xh,
|  | const Expr & | expr )

Definition at line 264 of file interpolate.h.

## reset() [1/3]

template<class T>

void reset | ( | T & | x | ) |

Definition at line 31 of file keller_details.h.

## reset() [2/3]

template<class T>

void reset | ( | std::valarray< T > & | x | ) |

Definition at line 34 of file keller_details.h.

## reset() [3/3]

template<class T1, class T2>

void reset | ( | pair_with_linear_algebra< T1, T2 > & | x | ) |

Definition at line 38 of file keller_details.h.

## max_abs() [1/3]

template<class T>

T max_abs | ( | const T & | x | ) |

Definition at line 47 of file keller_details.h.

## max_abs() [2/3]

template<class T>

T max_abs | ( | const field_basic< T > & | x | ) |

Definition at line 50 of file keller_details.h.

## max_abs() [3/3]

template<class T>

field_basic< T >::float_type max_abs | ( | const std::valarray< field_basic< T > > & | x | ) |

Definition at line 54 of file keller_details.h.

## get_unknown() [1/7]

template<class T>

size_t get_unknown | ( | const T & | x | ) |

Definition at line 65 of file keller_details.h.

## unknown_size() [1/2]

template<class T>

size_t unknown_size | ( | const field_basic< T > & | x | ) |

Definition at line 69 of file keller_details.h.

## unknown_size() [2/2]

template<class T>

size_t unknown_size | ( | const std::valarray< field_basic< T > > & | x | ) |

Definition at line 73 of file keller_details.h.

## get_unknown() [2/7]

template<class T>

T get_unknown | ( | const T & | x | ) |

Definition at line 84 of file keller_details.h.

## get_unknown() [3/7]

template<class T>

T get_unknown | ( | const T & | x,
|  | const distributor & | )

Definition at line 86 of file keller_details.h.

## get_unknown() [4/7]

template<class T>

vec< T > get_unknown | ( | const field_basic< T > & | x | ) |

Definition at line 89 of file keller_details.h.

## get_unknown() [5/7]

template<class T>

vec< T > get_unknown | ( | const field_basic< T > & | x,
|  | const distributor & | )

Definition at line 91 of file keller_details.h.

## get_unknown() [6/7]

template<class T>

vec< T > get_unknown | ( | const std::valarray< field_basic< T > > & | x,
|  | const distributor & | ownership )

Definition at line 94 of file keller_details.h.

## get_unknown() [7/7]

template<class T>

vec< T > get_unknown | ( | const std::valarray< field_basic< T > > & | x | ) |

Definition at line 104 of file keller_details.h.

## set_unknown() [1/3]

template<class T>

void set_unknown | ( | T & | x,
|  | const T & | value )

Definition at line 119 of file keller_details.h.

## set_unknown() [2/3]

template<class T>

void set_unknown | ( | field_basic< T > & | x,
|  | const vec< T > & | value )

Definition at line 122 of file keller_details.h.

## set_unknown() [3/3]

template<class T>

void set_unknown | ( | std::valarray< field_basic< T > > & | x,
|  | const vec< T > & | value )

Definition at line 129 of file keller_details.h.

## minmod()

template<class T>

T minmod | ( | const T & | a,
|  | const T & | b )

Definition at line 36 of file limiter.cc.

## minmod_tvb()

template<class T>

T minmod_tvb | ( | const T & | yield_a,
|  | const T & | a,
|  | const T & | b )

Definition at line 51 of file limiter.cc.

## _RHEOLEF_has_inherited_member_macro() [1/5]

_RHEOLEF_has_inherited_member_macro | ( | adapt |  | ) |

## _RHEOLEF_has_inherited_member_macro() [2/5]

_RHEOLEF_has_inherited_member_macro | ( | refresh |  | ) |

## _RHEOLEF_has_inherited_member_macro() [3/5]

_RHEOLEF_has_inherited_member_macro | ( | direction |  | ) |

## _RHEOLEF_has_inherited_member_macro() [4/5]

_RHEOLEF_has_inherited_member_macro | ( | space_norm |  | ) |

## _RHEOLEF_has_inherited_member_macro() [5/5]

_RHEOLEF_has_inherited_member_macro | ( | dual_space_norm |  | ) |

## operator-() [1/2]

template<class T1, class T2>

pair_with_linear_algebra< T1, T2 > operator- | ( | const pair_with_linear_algebra< T1, T2 > & | x | ) |

Definition at line 58 of file pair_with_linear_algebra.h.

## operator*()

template<class T0, class T1, class T2>

pair_with_linear_algebra< T1, T2 > operator* | ( | const T0 & | k,
|  | const pair_with_linear_algebra< T1, T2 > & | x )

Definition at line 64 of file pair_with_linear_algebra.h.

## operator+()

template<class T1, class T2>

pair_with_linear_algebra< T1, T2 > operator+ | ( | const pair_with_linear_algebra< T1, T2 > & | x,
|  | const pair_with_linear_algebra< T1, T2 > & | y )

Definition at line 70 of file pair_with_linear_algebra.h.

## operator-() [2/2]

template<class T1, class T2>

pair_with_linear_algebra< T1, T2 > operator- | ( | const pair_with_linear_algebra< T1, T2 > & | x,
|  | const pair_with_linear_algebra< T1, T2 > & | y )

Definition at line 76 of file pair_with_linear_algebra.h.

## riesz_function_internal() [1/2]

template<class T, class M, class Geo, class Function>

field_basic< T, M > riesz_function_internal | ( | const space_basic< T, M > & | Xh,
|  | const Function & | f,
|  | const quadrature_option & | qopt,
|  | const Geo & | dom,
|  | std::false_type | )

Definition at line 40 of file riesz.h.

## riesz_function_internal() [2/2]

template<class T, class M, class Geo, class Function>

field_basic< T, M > riesz_function_internal | ( | const space_basic< T, M > & | Xh,
|  | const Function & | f,
|  | const quadrature_option & | qopt,
|  | const Geo & | dom,
|  | std::true_type | )

Definition at line 53 of file riesz.h.

## riesz_tag2() [1/3]

template<class T, class M, class Geo, class Function>

field_basic< T, M > riesz_tag2 | ( | const space_basic< T, M > & | Xh,
|  | const Function & | f,
|  | const quadrature_option & | qopt,
|  | const Geo & | dom,
|  | const T & | )

Definition at line 68 of file riesz.h.

## riesz_tag2() [2/3]

template<class T, class M, class Geo, class Function>

field_basic< T, M > riesz_tag2 | ( | const space_basic< T, M > & | Xh,
|  | const Function & | f,
|  | const quadrature_option & | qopt,
|  | const Geo & | dom,
|  | const point_basic< T > & | )

Definition at line 79 of file riesz.h.

## riesz_tag2() [3/3]

template<class T, class M, class Geo, class Function>

field_basic< T, M > riesz_tag2 | ( | const space_basic< T, M > & | Xh,
|  | const Function & | f,
|  | const quadrature_option & | qopt,
|  | const Geo & | dom,
|  | const undeterminated_basic< T > & | )

Definition at line 90 of file riesz.h.

## riesz_tag() [1/3]

template<class T, class M, class Geo, class Function>

std::enable_if< is_field_function< Function >::value, field_basic< T, M > >::type riesz_tag | ( | const space_basic< T, M > & | Xh,
|  | const Function & | f,
|  | const quadrature_option & | qopt,
|  | const Geo & | dom,
|  | std::false_type | )

Definition at line 113 of file riesz.h.

## riesz_tag() [2/3]

template<class T, class M, class Geo, class Function>

std::enable_if<!is_field_function< Function >::value, field_basic< T, M > >::type riesz_tag | ( | const space_basic< T, M > & | Xh,
|  | const Function & | f,
|  | const quadrature_option & | qopt,
|  | const Geo & | dom,
|  | std::false_type | )

Definition at line 130 of file riesz.h.

## riesz_tag() [3/3]

template<class T, class M, class Geo, class Constant>

field_basic< T, M > riesz_tag | ( | const space_basic< T, M > & | Xh,
|  | const Constant & | value,
|  | const quadrature_option & | qopt,
|  | const Geo & | dom,
|  | std::true_type | )

Definition at line 144 of file riesz.h.

## Variable Documentation

## dot

rheolef::details::is_vec dot

## compose

class rheolef::details::field_expr_v2_nonlinear_node_unary compose