Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
rheolef::details Namespace Reference

Namespaces

namespace  jacobi
 
namespace  legendre
 

Classes

class  add_adapt< Problem, std::false_type >
 
class  add_adapt< Problem, std::true_type >
 
class  add_direction< Problem, std::false_type >
 
class  add_direction< Problem, std::true_type >
 
class  add_dual_space_norm< Problem, std::false_type >
 
class  add_dual_space_norm< Problem, std::true_type >
 
class  add_missing_continuation
 
class  add_missing_damped_newton
 
class  add_refresh< Problem, std::false_type >
 
class  add_refresh< Problem, std::true_type >
 
class  add_space_norm< Problem, std::false_type >
 
class  add_space_norm< Problem, std::true_type >
 
struct  and_type
 
struct  and_type< B1 >
 
struct  and_type< B1, B2 >
 
struct  and_type< B1, B2, B3, Bn... >
 
struct  and_type<>
 
struct  assign_op
 
struct  bf_vf_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_00, vf_tag_10 >
 
struct  bf_vf_tag< multiplies, vf_tag_00, vf_tag_11 >
 
struct  bf_vf_tag< multiplies, vf_tag_01, vf_tag_00 >
 
struct  bf_vf_tag< multiplies, vf_tag_01, vf_tag_10 >
 
struct  bf_vf_tag< multiplies, vf_tag_10, vf_tag_00 >
 
struct  bf_vf_tag< multiplies, vf_tag_10, vf_tag_01 >
 
struct  bf_vf_tag< multiplies, vf_tag_11, vf_tag_00 >
 
struct  bf_vf_tag< plus, Tag, Tag >
 
struct  binder_first
 
struct  binder_second
 
struct  binop_error
 
struct  build_class_function
 
struct  build_class_function< C, R(Args...) const >
 
struct  build_class_function< C, R(Args...) volatile >
 
struct  build_class_function< C, R(Args...)>
 
struct  build_free_function
 
struct  build_free_function< F, R(Args...)>
 
struct  constant_promote
 
struct  constant_promote< int >
 
struct  constant_promote< size_t >
 
class  csr_concat
 
class  csr_concat_line
 
class  csr_concat_value
 
struct  dddot_
 
struct  dddot_result
 
struct  dddot_result< tensor3_basic< A1 >, tensor3_basic< A2 > >
 
struct  ddot_
 
struct  ddot_result
 
struct  ddot_result< tensor4_basic< A1 >, tensor_basic< A2 > >
 
struct  ddot_result< tensor_basic< A1 >, tensor4_basic< A2 > >
 
struct  ddot_result< tensor_basic< A1 >, tensor_basic< A2 > >
 
struct  decay_is_same
 
struct  default_set_op_traits< index_set >
 
struct  default_set_op_traits< pair_set< T, A > >
 
struct  differentiate_option
 
struct  divides
 
struct  divides_assign
 
struct  divides_result
 
struct  divides_result< point_basic< T >, T >
 
struct  divides_result< point_basic< T1 >, tensor3_basic< T2 > >
 
struct  divides_result< point_basic< T1 >, tensor4_basic< T2 > >
 
struct  divides_result< point_basic< T1 >, tensor_basic< T2 > >
 
struct  divides_result< T, point_basic< T > >
 
struct  divides_result< T, T, typename std::enable_if< ! is_rheolef_arithmetic< T >::value &&! is_undeterminated< T >::value >::type >
 
struct  divides_result< T, tensor3_basic< T > >
 
struct  divides_result< T, tensor4_basic< T > >
 
struct  divides_result< T, tensor_basic< T > >
 
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< tensor3_basic< T >, T >
 
struct  divides_result< tensor3_basic< T1 >, point_basic< T2 > >
 
struct  divides_result< tensor3_basic< T1 >, tensor4_basic< T2 > >
 
struct  divides_result< tensor3_basic< T1 >, tensor_basic< T2 > >
 
struct  divides_result< tensor4_basic< T >, T >
 
struct  divides_result< tensor_basic< T >, T >
 
struct  divides_result< tensor_basic< T1 >, point_basic< T2 > >
 
struct  divides_result< tensor_basic< T1 >, tensor3_basic< T2 > >
 
struct  divides_result< tensor_basic< T1 >, tensor4_basic< T2 > >
 
struct  dual_vf_tag
 
struct  dual_vf_tag< vf_tag_00 >
 
struct  dual_vf_tag< vf_tag_01 >
 
struct  dual_vf_tag< vf_tag_10 >
 
struct  dual_vf_tag< vf_tag_11 >
 
struct  f_constant
 
class  field_concat
 
class  field_concat_value
 
class  field_expr_quadrature_binary
 
class  field_expr_quadrature_on_element
 
class  field_expr_quadrature_on_sides
 
class  field_expr_v2_nonlinear_node_nary
 
class  field_expr_v2_nonlinear_node_unary
 
class  field_expr_v2_nonlinear_terminal_field
 
class  field_expr_v2_nonlinear_terminal_field_dg
 
class  field_expr_v2_nonlinear_terminal_field_dg_rep
 
class  field_expr_v2_nonlinear_terminal_field_o_characteristic
 
class  field_expr_v2_nonlinear_terminal_field_o_characteristic_rep
 
class  field_expr_v2_nonlinear_terminal_field_rep
 
class  field_expr_v2_nonlinear_terminal_function
 
class  field_expr_v2_nonlinear_terminal_function_base_rep
 
class  field_expr_v2_nonlinear_terminal_function_rep
 
class  field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >
 
class  field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >
 
class  field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >
 
struct  field_expr_v2_nonlinear_terminal_wrapper_traits
 
struct  field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< has_field_rdof_interface< 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  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 >
 
class  field_expr_v2_variational_binary
 
class  field_expr_v2_variational_binary_binded
 
class  field_expr_v2_variational_curl
 
class  field_expr_v2_variational_dg
 
class  field_expr_v2_variational_div
 
class  field_expr_v2_variational_grad
 
class  field_expr_v2_variational_unary
 
struct  field_function_traits
 
struct  field_function_traits< F, typename std::enable_if< is_field_functor< F >::value >::type >
 
struct  field_function_traits< F, typename std::enable_if< is_field_true_function< F >::value >::type >
 
class  field_indirect_base
 
class  field_indirect_const_iterator
 
class  field_indirect_iterator
 
class  field_lazy_add
 
class  field_lazy_base
 
class  field_lazy_mult_form
 
class  field_lazy_mult_form_rep
 
class  field_lazy_terminal_field
 
class  field_lazy_terminal_integrate
 
class  field_lazy_terminal_integrate_band
 
class  field_lazy_terminal_integrate_band_rep
 
class  field_lazy_terminal_integrate_rep
 
class  field_lazy_terminal_interpolate
 
class  field_lazy_terminal_interpolate_rep
 
class  field_lazy_trans_mult_form
 
class  field_lazy_trans_mult_form_rep
 
class  field_lazy_unop
 
class  field_nonlinear_expr
 
struct  field_promote_first_argument
 
struct  field_promote_second_argument
 
class  field_rdof_base
 
class  field_rdof_indirect_const
 
class  field_rdof_sliced_base
 
class  field_rdof_sliced_const
 
class  field_rdof_unary
 
class  field_rdof_unary_iterator
 
class  field_sliced_const_iterator
 
class  field_sliced_iterator
 
struct  field_traits
 
struct  field_traits< field_basic< T, M > >
 
struct  field_traits< field_rdof_indirect_const< FieldRdof > >
 
struct  field_traits< field_rdof_sliced_const< FieldRdof > >
 
struct  field_traits< field_rdof_unary< UnaryFunction, FieldRdof > >
 
struct  field_traits< field_wdof_indirect< FieldWdof > >
 
struct  field_traits< field_wdof_sliced< FieldWdof > >
 
struct  field_wdof2rdof_traits
 
struct  field_wdof2rdof_traits< field_wdof_indirect< FieldWdof > >
 
struct  field_wdof2rdof_traits< field_wdof_sliced< FieldWdof > >
 
class  field_wdof_base
 
class  field_wdof_indirect
 
class  field_wdof_sliced
 
class  form_concat
 
class  form_concat_line
 
class  form_concat_value
 
class  form_expr_quadrature_binary
 
class  form_expr_quadrature_on_element
 
class  form_expr_quadrature_on_sides
 
class  form_expr_quadrature_unary
 
class  form_expr_v2_variational_binary
 
class  form_expr_v2_variational_binary_binded
 
class  form_expr_v2_variational_binary_field
 
class  form_expr_v2_variational_unary
 
class  form_lazy_add
 
class  form_lazy_base
 
class  form_lazy_invert
 
class  form_lazy_invert_rep
 
class  form_lazy_multiply
 
class  form_lazy_multiply_rep
 
class  form_lazy_terminal_integrate
 
class  form_lazy_terminal_integrate_band
 
class  form_lazy_terminal_integrate_band_rep
 
class  form_lazy_terminal_integrate_rep
 
class  form_lazy_transpose
 
class  form_lazy_unop
 
struct  function_traits
 
struct  function_traits< field_basic< T, M > >
 
struct  function_traits< R(*)(Args...)>
 
struct  function_traits< R(Args...)>
 
struct  function_wrapper
 
struct  function_wrapper< Result(Arg)>
 
struct  function_wrapper< Result(Arg1, Arg2)>
 
struct  functor_traits
 
struct  functor_traits< R(C::*)(Args...) const >
 
struct  generic_binary_traits
 
struct  generic_binary_traits< dddot_ >
 
struct  generic_binary_traits< ddot_ >
 
struct  generic_binary_traits< divides >
 
struct  generic_binary_traits< dot_ >
 
struct  generic_binary_traits< minus >
 
struct  generic_binary_traits< multiplies >
 
struct  generic_binary_traits< plus >
 
struct  generic_binary_traits< swapper< BinaryFunction > >
 
class  generic_binder1st
 
struct  generic_binder2nd
 
struct  generic_unary_traits
 
struct  generic_unary_traits< binder_first< BinaryFunction, A1 > >
 
struct  generic_unary_traits< binder_second< BinaryFunction, A2 > >
 
struct  generic_unary_traits< negate >
 
struct  generic_unary_traits< norm2_ >
 
struct  generic_unary_traits< norm_ >
 
struct  generic_unary_traits< tr_ >
 
struct  generic_unary_traits< trans_ >
 
struct  generic_unary_traits< unary_plus >
 
struct  get_functor_result
 
struct  get_functor_result< F, typename std::enable_if< std::is_member_function_pointer< decltype(&F::operator())>::value >::type >
 
struct  get_functor_result_impl
 
struct  get_functor_result_impl< C, R(C::*)(Args...) const >
 
struct  get_functor_result_impl< C, R(C::*)(Args...) volatile >
 
struct  get_functor_result_impl< C, R(C::*)(Args...)>
 
struct  h_local_pseudo_function
 
struct  has_field_lazy_interface
 
struct  has_field_lazy_interface< field_expr_v2_nonlinear_node_nary< F, Exprs... > >
 
struct  has_field_lazy_interface< FieldLazy, typename std::enable_if< has_field_rdof_interface< FieldLazy >::value >::type >
 
struct  has_field_lazy_interface< FieldLazy, typename std::enable_if< is_field_lazy< FieldLazy >::value >::type >
 
struct  has_field_rdof_interface
 
struct  has_field_rdof_interface< FieldRdof, typename std::enable_if< has_field_wdof_interface< FieldRdof >::value >::type >
 
struct  has_field_rdof_interface< FieldRdof, typename std::enable_if< is_field_rdof< FieldRdof >::value >::type >
 
struct  has_field_wdof_interface
 
struct  has_field_wdof_interface< FieldWdof, typename std::enable_if< is_field< FieldWdof >::value >::type >
 
struct  has_field_wdof_interface< FieldWdof, typename std::enable_if< is_field_wdof< FieldWdof >::value >::type >
 
struct  index_list
 
struct  interpolate_internal_check
 
struct  interpolate_internal_check< T, M, Expr, point_basic< T >, std::true_type >
 
struct  interpolate_internal_check< T, M, Expr, 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  is_callable
 
struct  is_callable< Signature, Signature >
 
struct  is_callable_impl
 
struct  is_callable_impl< F, S, false >
 
struct  is_class_reference
 
struct  is_class_reference< disarray_dis_reference< T, A > >
 
struct  is_constant
 
struct  is_container
 
struct  is_container< index_set >
 
struct  is_container< pair_set< T, A > >
 
struct  is_container_of_mpi_datatype
 
struct  is_container_of_mpi_datatype< index_set >
 
struct  is_container_of_mpi_datatype< pair_set< T, A > >
 
struct  is_equal
 
struct  is_equal< T, T >
 
struct  is_error
 
struct  is_error< binop_error< Op, T1, T2, R > >
 
struct  is_expr
 
struct  is_expr< field_nonlinear_expr< E > >
 
struct  is_field
 
struct  is_field< field_basic< T, M > >
 
struct  is_field_expr_affine_homogeneous
 
struct  is_field_expr_affine_homogeneous< Expr, typename std::enable_if< has_field_rdof_interface< Expr >::value >::type >
 
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< 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  is_field_expr_affine_homogeneous< field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none > >
 
struct  is_field_expr_quadrature_arg
 
struct  is_field_expr_quadrature_arg< field_expr_quadrature_binary< F, Expr1, Expr2 > >
 
struct  is_field_expr_quadrature_arg< field_expr_quadrature_on_element< Expr > >
 
struct  is_field_expr_quadrature_arg< field_expr_quadrature_on_sides< Expr > >
 
struct  is_field_expr_v2_constant
 
struct  is_field_expr_v2_nonlinear_arg
 
struct  is_field_expr_v2_nonlinear_arg< Expr, typename std::enable_if< has_field_rdof_interface< Expr >::value >::type >
 
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< F, typename std::enable_if< std::conjunction< std::negation< has_field_rdof_interface< F > >, is_field_function< F > >::value >::type >
 
struct  is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_node_nary< F, Exprs... > >
 
struct  is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_node_unary< F, Expr > >
 
struct  is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_terminal_field< T, M, Diff > >
 
struct  is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_terminal_field_dg< T, M > >
 
struct  is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_terminal_field_o_characteristic< T, M > >
 
struct  is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_terminal_function< F > >
 
struct  is_field_expr_v2_variational_arg
 
struct  is_field_expr_v2_variational_arg< field_expr_v2_variational_binary< F, Expr1, Expr2 > >
 
struct  is_field_expr_v2_variational_arg< field_expr_v2_variational_binary_binded< F, Expr1, Expr2 > >
 
struct  is_field_expr_v2_variational_arg< field_expr_v2_variational_curl< Expr > >
 
struct  is_field_expr_v2_variational_arg< field_expr_v2_variational_dg< Expr > >
 
struct  is_field_expr_v2_variational_arg< field_expr_v2_variational_div< Expr > >
 
struct  is_field_expr_v2_variational_arg< field_expr_v2_variational_grad< Expr > >
 
struct  is_field_expr_v2_variational_arg< field_expr_v2_variational_unary< F, Expr > >
 
struct  is_field_expr_v2_variational_arg< test_basic< T, M, VfTag > >
 
struct  is_field_expr_v2_variational_arg< test_component< T, M, VfTag > >
 
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  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  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  is_field_function< field_wdof_indirect< FieldWdof > >
 
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_lazy
 
struct  is_field_lazy< field_lazy_add< Binop, Expr1, Expr2 > >
 
struct  is_field_lazy< field_lazy_mult_form< FormExpr, FieldExpr > >
 
struct  is_field_lazy< field_lazy_terminal_field< T, M > >
 
struct  is_field_lazy< field_lazy_terminal_integrate< Expr > >
 
struct  is_field_lazy< field_lazy_terminal_integrate_band< Expr > >
 
struct  is_field_lazy< field_lazy_terminal_interpolate< Expr > >
 
struct  is_field_lazy< field_lazy_trans_mult_form< FormExpr, FieldExpr > >
 
struct  is_field_lazy< field_lazy_unop< Unop, Expr > >
 
struct  is_field_rdof
 
struct  is_field_rdof< field_rdof_indirect_const< FieldRdof > >
 
struct  is_field_rdof< field_rdof_unary< UnaryFunction, FieldRdof > >
 
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_wdof
 
struct  is_field_wdof< field_rdof_sliced_const< FieldRdof > >
 
struct  is_field_wdof< field_wdof_indirect< FieldWdof > >
 
struct  is_field_wdof< field_wdof_sliced< FieldWdof > >
 
struct  is_form_expr_quadrature_arg
 
struct  is_form_expr_quadrature_arg< form_expr_quadrature_binary< F, Expr1, Expr2 > >
 
struct  is_form_expr_quadrature_arg< form_expr_quadrature_on_element< Expr > >
 
struct  is_form_expr_quadrature_arg< form_expr_quadrature_on_sides< Expr > >
 
struct  is_form_expr_quadrature_arg< form_expr_quadrature_unary< F, Expr > >
 
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_quadrature_on_side_arg
 
struct  is_form_expr_quadrature_on_side_arg< form_expr_quadrature_on_sides< Expr > >
 
struct  is_form_expr_v2_variational_arg
 
struct  is_form_expr_v2_variational_arg< form_expr_v2_variational_binary< F, Expr1, Expr2 > >
 
struct  is_form_expr_v2_variational_arg< form_expr_v2_variational_binary_binded< F, Expr1, Expr2 > >
 
struct  is_form_expr_v2_variational_arg< form_expr_v2_variational_binary_field< F, Expr1, Expr2 > >
 
struct  is_form_expr_v2_variational_arg< form_expr_v2_variational_unary< F, Expr > >
 
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 >
 
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
 
struct  is_form_lazy
 
struct  is_form_lazy< form_lazy_add< Binop, Expr1, Expr2 > >
 
struct  is_form_lazy< form_lazy_invert< Expr > >
 
struct  is_form_lazy< form_lazy_multiply< Expr1, Expr2 > >
 
struct  is_form_lazy< form_lazy_terminal_integrate< Expr > >
 
struct  is_form_lazy< form_lazy_terminal_integrate_band< Expr > >
 
struct  is_form_lazy< form_lazy_transpose< Expr > >
 
struct  is_form_lazy< form_lazy_unop< Unop, Expr > >
 
struct  is_function
 
struct  is_function_with_signature
 
struct  is_functor
 
struct  is_functor< F, typename std::enable_if< get_functor_result< F >::value >::type >
 
struct  is_functor_with_signature
 
struct  is_point
 
struct  is_point< point_basic< T > >
 
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  is_scalar
 
struct  is_scalar< const int >
 
struct  is_scalar< double >
 
struct  is_scalar< int >
 
struct  is_scalar< size_t >
 
struct  is_tensor
 
struct  is_tensor3
 
struct  is_tensor3< tensor3_basic< T > >
 
struct  is_tensor4
 
struct  is_tensor4< tensor4_basic< T > >
 
struct  is_tensor< tensor_basic< T > >
 
struct  is_vec
 
struct  is_vec< vec< T, M > >
 
struct  is_vec_expr_v2_arg
 
struct  is_vec_expr_v2_arg< vec< T, M > >
 
struct  is_vec_expr_v2_arg< vec_expr_v2_binary< Op, Expr1, Expr2 > >
 
struct  is_vec_expr_v2_arg< vec_expr_v2_unary< Op, Expr > >
 
struct  is_vector_function
 
struct  is_vector_function< point_basic< T >(const point_basic< T >)>
 
struct  iterator_on_constant
 
struct  memorized_disarray
 
class  memorized_matrix
 
class  memorized_side_value
 
struct  memorized_vector
 
struct  minus
 
struct  minus_assign
 
struct  multiplies
 
struct  multiplies_assign
 
struct  multiplies_result
 
struct  multiplies_result< point_basic< S >, S >
 
struct  multiplies_result< point_basic< S1 >, point_basic< S2 > >
 
struct  multiplies_result< point_basic< S1 >, tensor3_basic< S2 > >
 
struct  multiplies_result< point_basic< S1 >, tensor4_basic< S2 > >
 
struct  multiplies_result< point_basic< S1 >, tensor_basic< S2 > >
 
struct  multiplies_result< S, point_basic< S > >
 
struct  multiplies_result< S, tensor3_basic< S > >
 
struct  multiplies_result< S, tensor4_basic< S > >
 
struct  multiplies_result< S, tensor_basic< S > >
 
struct  multiplies_result< tensor3_basic< S >, S >
 
struct  multiplies_result< tensor3_basic< S1 >, point_basic< S2 > >
 
struct  multiplies_result< tensor3_basic< S1 >, tensor3_basic< S2 > >
 
struct  multiplies_result< tensor3_basic< S1 >, tensor4_basic< S2 > >
 
struct  multiplies_result< tensor3_basic< S1 >, tensor_basic< S2 > >
 
struct  multiplies_result< tensor4_basic< S >, S >
 
struct  multiplies_result< tensor4_basic< S1 >, point_basic< S2 > >
 
struct  multiplies_result< tensor4_basic< S1 >, tensor3_basic< S2 > >
 
struct  multiplies_result< tensor4_basic< S1 >, tensor4_basic< S2 > >
 
struct  multiplies_result< tensor4_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 >, tensor3_basic< S2 > >
 
struct  multiplies_result< tensor_basic< S1 >, tensor4_basic< S2 > >
 
struct  multiplies_result< tensor_basic< S1 >, tensor_basic< S2 > >
 
struct  negate
 
struct  nl_switch
 
struct  nl_switch< This, point_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 > >
 
struct  nl_switch< This, tensor_basic< typename This::scalar_type > >
 
struct  nl_switch< This, typename This::scalar_type >
 
struct  norm2_
 
struct  norm_
 
struct  normal_pseudo_function
 
struct  not_type
 
struct  or_type
 
struct  or_type< B1 >
 
struct  or_type< B1, B2 >
 
struct  or_type< B1, B2, B3, Bn... >
 
struct  or_type<>
 
struct  pair_with_linear_algebra
 
struct  penalty_pseudo_function
 
struct  plus
 
struct  plus_assign
 
struct  plus_result
 
struct  plus_result< A, A, typename std::enable_if< ! is_rheolef_arithmetic< A >::value >::type >
 
struct  plus_result< A1, A2, typename std::enable_if< is_rheolef_arithmetic< A1 >::value &&is_rheolef_arithmetic< A2 >::value >::type >
 
struct  range_builder
 
struct  range_builder< MIN, MIN, Is... >
 
struct  result_type
 
struct  result_type< R(*)(const point_basic< T > &)>
 
struct  result_type< R(const point_basic< T > &)>
 
struct  scalar_binary_traits
 
struct  swapper
 
class  test_component
 
class  test_component_rep
 
struct  trans_
 
struct  true_function_traits
 
struct  true_function_traits< R(*)(Args...)>
 
struct  true_function_traits< R(Args...)>
 
struct  uf_vf_tag
 
struct  uf_vf_tag< negate, Tag >
 
struct  uf_vf_tag< unary_plus, Tag >
 
struct  unary_plus
 
struct  upgrade_integral_to_float
 
struct  upgrade_integral_to_float< Int, typename std::enable_if< std::is_integral< Int >::value, Int >::type >
 
class  vec_concat
 
class  vec_concat_value
 
struct  vec_expr_v2_binary
 
struct  vec_expr_v2_binary_traits
 
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  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_unary
 
struct  vec_trans
 
struct  vector_field_trans
 
struct  vector_vec_trans
 
struct  vf_tag_nonlinear
 
struct  zero_dimension
 

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_elementglobal_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< Texpr_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, Minterpolate_generic (const space_basic< T, M > &Xh, const Expr &expr0)
 
template<class T , class M , class Expr , class Result >
field_basic< T, Minterpolate_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< Tget_unknown (const field_basic< T > &x)
 
template<class T >
vec< Tget_unknown (const field_basic< T > &x, const distributor &)
 
template<class T >
vec< Tget_unknown (const std::valarray< field_basic< T > > &x, const distributor &ownership)
 
template<class T >
vec< Tget_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, Mriesz_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, Mriesz_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, Mriesz_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, Mriesz_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, Mriesz_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, Mriesz_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  )
protected

◆ 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 
)
protected

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 
)
protected

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(*)(Arg)  f)

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(*)(Arg1, Arg2)  f)

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 
)
protected

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

◆ compose