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