OpenKalman::detail Namespace Reference

T is an acceptable noise perturbation input to a tests. More...

Classes
struct	common_ref
struct	common_ref< A &&, B &&, std::enable_if_t< std::is_convertible_v< A &&, common_ref_C< A, B > > and std::is_convertible_v< B &&, common_ref_C< A, B > > > >
struct	common_ref< A &&, B &, std::enable_if_t< std::is_convertible_v< A &&, common_ref_D< A, B > > > >
struct	common_ref< A &, B && >
struct	common_ref< A &, B &, std::void_t< cond_res_cvref< A, B > > >
struct	common_reference_impl
struct	common_reference_impl< T1 &&, T2 &&, 1, std::void_t< common_ref_t< T1 &&, T2 && > > >
struct	common_reference_impl< T1 &&, T2 &, 1, std::void_t< common_ref_t< T1 &&, T2 & > > >
struct	common_reference_impl< T1 &, T2 &&, 1, std::void_t< common_ref_t< T1 &, T2 && > > >
struct	common_reference_impl< T1 &, T2 &, 1, std::void_t< common_ref_t< T1 &, T2 & > > >
struct	common_reference_impl< T1, T2, 3, std::void_t< cond_res< T1, T2 > > >
struct	common_reference_impl< T1, T2, 4, std::void_t< std::common_type_t< T1, T2 > > >
struct	common_reference_impl< T1, T2, 5, void >
struct	compatible_with_vector_space_descriptor_collection_impl
struct	compatible_with_vector_space_descriptor_collection_impl< T, D, std::enable_if_t< pattern_tuple< D > > >
struct	constant_concatenate_arguments_impl
struct	constant_concatenate_arguments_impl< T, std::enable_if_t<(values::internal::near(constant_coefficient< T >::value, constant_coefficient< Ts >::value) and ...)>, Ts... >
struct	constant_transpose_defined_for
struct	constant_transpose_defined_for< T, Arg, std::enable_if_t< constant_matrix< decltype(interface::library_interface< T >::transpose(std::declval< Arg >()))> > >
struct	convertible_to_impl
struct	convertible_to_impl< From, To, std::void_t< decltype(static_cast< To >(std::declval< From >()))> >
struct	count_is_zero
struct	count_is_zero< T, std::enable_if_t< std::decay_t< decltype(count_indices(std::declval< const T & >()))>::value==0 > >
struct	dimension_size_of_index_is_impl
struct	dimension_size_of_index_is_impl< T, index, value, std::enable_if_t< index_dimension_of< T, index >::value==value > >
struct	dynamic_count_indices_defined
struct	dynamic_count_indices_defined< T, std::enable_if_t< interface::count_indices_defined_for< T > > >
struct	EigenWrapperEvaluatorBase
struct	EigenWrapperEvaluatorBase< XprType, Nested, std::enable_if_t< OpenKalman::Eigen3::eigen_dense_general< Nested > > >
struct	equivalent_to_uniform_static_vector_space_descriptor_component_of_impl
struct	equivalent_to_uniform_static_vector_space_descriptor_component_of_impl< T, C, std::enable_if_t< compares_with< T, typename uniform_static_vector_space_descriptor_component_of< C >::type > > >
struct	has_layout
struct	has_layout< T, std::void_t< decltype(interface::indexible_object_traits< T >::layout)> >
struct	has_member_difference_type
struct	has_member_difference_type< T, std::void_t< typename T::difference_type > >
struct	hermitian_adapter_impl
struct	hermitian_adapter_impl< T, t, std::enable_if_t<(t==HermitianAdapterType::any ? interface::indexible_object_traits< std::decay_t< T >>::hermitian_adapter_type==HermitianAdapterType::lower or interface::indexible_object_traits< std::decay_t< T >>::hermitian_adapter_type==HermitianAdapterType::upper :interface::indexible_object_traits< std::decay_t< T >>::hermitian_adapter_type==t)> >
struct	index_range_for_impl
struct	index_range_for_impl< Indices, Indexible, std::enable_if_t< collections::size_of< Indices >::value==dynamic_size or index_count< Indexible >::value==dynamic_size or collections::size_of< Indices >::value >=index_count< Indexible >::value >
struct	index_range_for_impl_it
struct	index_range_for_impl_it< Indices, Indexible, std::enable_if_t< values::index< ranges::iterator_t< Indices > > > >
struct	is_bidirectional_iterator
struct	is_bidirectional_iterator< I, std::enable_if_t< std::is_same< decltype(--std::declval< I & >()), I & >::value and std::is_same< decltype(std::declval< I & >() --), I >::value > >
struct	is_cholesky_form
struct	is_cholesky_form< T, std::enable_if_t< covariance< T > > >
struct	is_constant_adapter
struct	is_constant_adapter< ConstantAdapter< PatternMatrix, Scalar, constant... > >
struct	is_dynamic_dimension
struct	is_dynamic_dimension< T, N, std::enable_if_t< indexible< T > and index_dimension_of< T, N >::value==dynamic_size > >
struct	is_from_euclidean_expr
struct	is_from_euclidean_expr< FromEuclideanExpr< NestedMatrix, D > >
struct	is_identity_matrix
struct	is_identity_matrix< T, std::enable_if_t< values::fixed< constant_diagonal_coefficient< T > > > >
struct	is_incrementable
struct	is_incrementable< I, std::enable_if_t< std::is_same< decltype(std::declval< I & >()++), I >::value > >
struct	is_indirectly_readable
struct	is_indirectly_readable< I, std::void_t< iter_value_t< I >, iter_reference_t< I >, iter_rvalue_reference_t< I > >, std::enable_if_t< std::is_same< decltype(*std::declval< I >()), iter_reference_t< I > >::value > >
struct	is_indirectly_writable
struct	is_indirectly_writable< Out, T, std::void_t< decltype(*std::declval< Out & >()=std::declval< T && >()), decltype(*std::declval< Out && >()=std::declval< T && >()), decltype(const_cast< const iter_reference_t< Out > && >(*std::declval< Out & >())=std::declval< T && >()), decltype(const_cast< const iter_reference_t< Out > && >(*std::declval< Out && >())=std::declval< T && >()) > >
struct	is_inferred_hermitian_matrix
struct	is_inferred_hermitian_matrix< T, std::enable_if_t< not values::complex< typename scalar_type_of< T >::type > or values::not_complex< constant_coefficient< T > > or values::not_complex< constant_diagonal_coefficient< T > > > >
struct	is_input_or_output_iterator
struct	is_input_or_output_iterator< I, std::void_t< iter_value_t< I >, iter_reference_t< I >, iter_rvalue_reference_t< I > >, std::enable_if_t< std::is_same< decltype(*std::declval< I >()), iter_reference_t< I > >::value > >
struct	is_perturbation
struct	is_perturbation< T, Coeffs, std::enable_if_t< gaussian_distribution< T > and compares_with< typename oin::PerturbationTraits< T >::RowCoefficients, Coeffs > > >
struct	is_perturbation< T, Coeffs, std::enable_if_t<(not gaussian_distribution< T >) and transformation_input< T, Coeffs > > >
struct	is_random_access_iterator
struct	is_random_access_iterator< I, std::enable_if_t< std::is_same_v< decltype(std::declval< I & >()+=std::declval< iter_difference_t< I >>()), I & > and std::is_same_v< decltype(std::declval< const I & >()+std::declval< iter_difference_t< I >>()), I > and std::is_same_v< decltype(std::declval< iter_difference_t< I >>()+std::declval< const I & >()), I > and std::is_same_v< decltype(std::declval< I & >() -=std::declval< iter_difference_t< I >>()), I & > and std::is_same_v< decltype(std::declval< const I & >() - std::declval< iter_difference_t< I >>()), I > and std::is_same_v< decltype(std::declval< const I & >()[std::declval< iter_difference_t< I >>()]), iter_reference_t< I > > > >
struct	is_std_dist
struct	is_std_dist< T, std::void_t< typename T::result_type >, std::void_t< typename T::param_type > >
struct	is_to_euclidean_expr
struct	is_to_euclidean_expr< ToEuclideanExpr< NestedObject > >
struct	is_triangular_adapter
struct	is_triangular_adapter< T, std::enable_if_t< interface::indexible_object_traits< std::decay_t< T > >::is_triangular_adapter > >
struct	is_weakly_incrementable
struct	is_weakly_incrementable< I, std::void_t< iter_difference_t< I >, decltype(std::declval< I & >()++)>, std::enable_if_t< std::is_same< decltype(++std::declval< I & >()), I & >::value > >
struct	is_wrappable
struct	is_zero
struct	is_zero< T, std::enable_if_t< values::fixed< constant_coefficient< T > > > >
struct	iter_difference_impl
struct	iter_difference_impl< T, std::void_t< typename std::iterator_traits< T >::difference_type > >
struct	iter_value_impl
struct	iter_value_impl< T, std::void_t< typename std::iterator_traits< T >::value_type > >
struct	n_ary_operator_impl
struct	n_ary_operator_impl< Op, Indices, std::enable_if_t< std::is_invocable< Op, typename std::add_lvalue_reference< typename scalar_type_of< Args >::type >::type... >::value or is_invocable_with_indices< Op, typename std::add_lvalue_reference< typename scalar_type_of< Args >::type >::type... >(std::make_index_sequence< Indices > {})>, Args... >
struct	n_ary_operator_traits
struct	n_ary_operator_traits_impl
struct	n_ary_operator_traits_impl< Op, indices, std::enable_if_t< is_invocable_with_indices< Op, Args... >(std::make_index_sequence< indices > {}) or std::is_invocable_v< Op, Args... > >, Args... >
struct	nested_is_vector
struct	nested_is_vector< T, N, std::enable_if_t< has_nested_object< T > > >
struct	one_dimensional_impl
struct	one_dimensional_impl< T, b, std::enable_if_t< index_count< T >::value !=dynamic_size and index_count< T >::value > 0 >
struct	one_dimensional_impl< T, b, std::enable_if_t< index_count< T >::value==0 > >
struct	one_dimensional_impl< T, b, std::enable_if_t< index_count< T >::value==dynamic_size > >
struct	output_iterator_impl
struct	output_iterator_impl< I, T, std::void_t< decltype(*std::declval< I & >()++=std::declval< T && >())> >
struct	RandomizeGenerator
struct	RandomizeOp
struct	square_shaped_impl
struct	static_count_indices_defined
struct	static_count_indices_defined< T, std::enable_if_t< interface::count_indices_defined_for< T > > >
struct	subtractable
struct	subtractable< I, S, std::enable_if_t< std::is_same_v< decltype(std::declval< const S & >() - std::declval< const I & >()), iter_difference_t< I > > and std::is_same_v< decltype(std::declval< const I & >() - std::declval< const S & >()), iter_difference_t< I > > > >
struct	value > 1)> >
struct	value >=1)> >
struct	vector_impl
struct	vector_impl< T, N, b, std::enable_if_t< index_count< T >::value !=dynamic_size > >
struct	WeaklyEqualityComparableWith
struct	WeaklyEqualityComparableWith< T, U, std::enable_if_t< std::is_convertible_v< decltype(std::declval< const T & >()==std::declval< const U & >()), bool > and std::is_convertible_v< decltype(std::declval< const T & >() !=std::declval< const U & >()), bool > and std::is_convertible_v< decltype(std::declval< const U & >()==std::declval< const T & >()), bool > and std::is_convertible_v< decltype(std::declval< const U & >() !=std::declval< const T & >()), bool > > >
struct	zero_dimension_count

Typedefs
template<typename From , typename To >
using	copy_cv = std::conditional_t< std::is_const_v< From >, std::conditional_t< std::is_volatile_v< From >, const volatile To, const To >, std::conditional_t< std::is_volatile_v< From >, volatile To, To > >
template<typename A , typename B >
using	cond_res = decltype(false ? std::declval< A(&)()>()() :std::declval< B(&)()>()())
template<typename A , typename B >
using	cond_res_cvref = cond_res< copy_cv< A, B > &, copy_cv< B, A > & >
template<typename A , typename B >
using	common_ref_t = typename common_ref< A, B >::type
template<typename A , typename B >
using	common_ref_C = std::remove_reference_t< common_ref_t< A &, B & > > &&
template<typename A , typename B >
using	common_ref_D = common_ref_t< const A &, B & >
template<typename T >
using	remove_cvref_t = std::remove_cv_t< std::remove_reference_t< T > >

Enumerations
enum	Ord : signed char { equivalent = 0, less = -1, greater = 1, unordered = 2 }

Functions
template<typename T >
constexpr T &	reference_wrapper_FUN (T &t) noexcept
template<typename T >
void	reference_wrapper_FUN (T &&)=delete
template<typename Dist , typename Means , typename Covariances , std::size_t ... ints>
auto	zip_dist (Means &&ms, Covariances &&cs, std::index_sequence< ints... >)
template<typename Arg >
decltype(auto) constexpr	to_nestable (Arg &&arg)
template<typename C , typename Expr , typename Arg >
auto	split_item_impl (Arg &&arg)
template<typename T , std::size_t... I>
constexpr bool	all_fixed_indices_are_euclidean_impl (std::index_sequence< I... >)
template<typename T , std::size_t N, std::size_t... Ix>
constexpr bool	compatible_extension (std::index_sequence< Ix... >)
template<typename T , typename D , std::size_t... Ix>
constexpr bool	is_compatible_descriptor_tuple (std::index_sequence< Ix... >)
template<typename T , Applicability b, std::size_t... Ix>
constexpr bool	has_0_dim (std::index_sequence< Ix... >)
template<typename T , Applicability b, std::size_t I, std::size_t... Is>
constexpr bool	has_1_by_1_dims (std::index_sequence< I, Is... >)
template<typename T , std::size_t I, std::size_t... Is>
constexpr bool	maybe_square_shaped (std::index_sequence< I, Is... >)
template<typename T , std::size_t N, Applicability b, std::size_t... Is>
constexpr bool	do_vector_impl (std::index_sequence< Is... >)
template<std::size_t I, typename T , typename... Ts>
constexpr bool	maybe_equivalent_descriptors_per_index ()
template<typename... Ts, std::size_t... Is>
constexpr bool	vector_space_descriptors_may_match_with_impl (std::index_sequence< Is... >)
template<typename T , std::size_t... I>
constexpr bool	wrappable_impl (std::index_sequence< I... >)
template<typename Arg , std::size_t... indices, std::size_t... Ix>
decltype(auto) constexpr	average_reduce_impl (Arg &&arg, std::index_sequence< indices... > indices_seq, std::index_sequence< Ix... > seq)
template<std::size_t ix, typename Best_d >
const Best_d &	chipwise_vector_space_descriptor_for (const Best_d &best_d)
template<std::size_t ix, typename Best_d , typename Arg , typename... Args>
decltype(auto)	chipwise_vector_space_descriptor_for (const Best_d &best_d, const Arg &arg, const Args &...args)
template<std::size_t... ix, typename Arg , typename... Args>
auto	make_chipwise_default (std::index_sequence< ix... >, const Arg &arg, const Args &...args)
template<bool uses_indices, std::size_t... indices, std::size_t... indices_ix, typename Ix_tup , typename M , typename Op , typename... Args>
constexpr void	chipwise_op_chip (std::index_sequence< indices... >, std::index_sequence< indices_ix... >, const Ix_tup &ix_tup, M &m, const Op &op, Args &&...args)
template<bool uses_indices, typename Indices , typename Ix_tup , typename M , typename Op , typename... Args>
constexpr void	chipwise_op (Indices indices, const Ix_tup &ix_tup, M &m, const Op &op, Args &&...args)
template<bool uses_indices, std::size_t index, std::size_t... indices, typename Indices_seq , typename Ix_tup , typename M , typename Op , typename... Args>
constexpr void	chipwise_op (Indices_seq indices_seq, const Ix_tup &ix_tup, M &m, const Op &op, Args &&...args)
template<std::size_t op_ix, typename OpResult >
auto	nullary_chipwise_vector_space_descriptor (const OpResult &op_result)
template<std::size_t op_ix, std::size_t index, std::size_t... indices, typename OpResult , typename I , typename... Is>
auto	nullary_chipwise_vector_space_descriptor (const OpResult &op_result, I i, Is...is)
template<std::size_t... indices, std::size_t... op_ix, typename OpResult , typename... Is>
auto	make_nullary_chipwise_default (std::index_sequence< op_ix... >, const OpResult &op_result, Is...is)
template<bool uses_indices, std::size_t... indices, std::size_t... index_ixs, typename Ix_tup , typename M , typename Op , typename... Args>
constexpr void	nullary_chipwise_op_chip (std::index_sequence< indices... >, std::index_sequence< index_ixs... >, const Ix_tup &ix_tup, M &m, const Op &op)
template<bool uses_indices, bool first, typename All_index_seq , typename Ix_tup , typename M , typename Op >
constexpr void	nullary_chipwise_op (All_index_seq all_index_seq, const Ix_tup &ix_tup, M &m, const Op &op)
template<bool uses_indices, bool first, std::size_t index, std::size_t... indices, typename All_index_seq , typename Ix_tup , typename M , typename Op , typename I , typename... Is>
constexpr void	nullary_chipwise_op (All_index_seq all_index_seq, const Ix_tup &ix_tup, M &m, const Op &op, I i, Is...is)
template<typename T , typename U , std::size_t... indices, std::size_t... I>
constexpr bool	concatenate_dimensions_match_impl (std::index_sequence< I... >)
template<std::size_t I, std::size_t... indices, typename DTup , typename... DTups>
decltype(auto) constexpr	concatenate_vector_space_descriptor_impl (DTup &&d_tup, DTups &&...d_tups)
template<std::size_t... indices, std::size_t... I, typename... DTups>
decltype(auto) constexpr	concatenate_vector_space_descriptor (std::index_sequence< I... >, DTups &&...d_tups)
template<std::size_t index, std::size_t... indices, typename Args_tup , std::size_t... all_indices, std::size_t... pos>
constexpr auto	concatenate_diag_impl (Args_tup &&args_tup, std::index_sequence< all_indices... >, std::index_sequence< pos... >)
template<std::size_t... indices, typename Ds_tup , typename Args_tup , std::size_t... all_indices, typename... Pos_seq>
constexpr auto	concatenate_diag (Ds_tup &&ds_tup, Args_tup &&args_tup, std::index_sequence< all_indices... > all_indices_seq, Pos_seq...pos_seq)
template<std::size_t... args_ix, std::size_t... pos>
constexpr auto	get_cat_indices (std::index_sequence<>, std::index_sequence<>, std::index_sequence< args_ix... >, std::index_sequence< pos... > pos_seq)
template<std::size_t ix, std::size_t... ixs, std::size_t... args_ix, std::size_t... pos>
constexpr auto	get_cat_indices (std::index_sequence< ix, ixs... >, std::index_sequence<> index_seq, std::index_sequence< args_ix... > arg_ix_seq, std::index_sequence< pos... >)
template<std::size_t ix, std::size_t... ixs, std::size_t index, std::size_t... indices, std::size_t... args_ix, std::size_t... pos>
constexpr auto	get_cat_indices (std::index_sequence< ix, ixs... > ix_seq, std::index_sequence< index, indices... > index_seq, std::index_sequence< args_ix... > arg_ix_seq, std::index_sequence< pos... > pos_seq)
template<typename Arg >
void	error_if_argument_to_determinant_is_not_square (const Arg &arg)
template<typename Arg , typename Indices >
decltype(auto) constexpr	get_component_impl (Arg &&arg, const Indices &indices)
template<bool is_offset, std::size_t arg_ix, typename Arg >
constexpr auto	get_block_limits (const Arg &arg)
template<bool is_offset, std::size_t arg_ix, std::size_t index, std::size_t... indices, typename Arg , typename Limit , typename... Limits>
constexpr auto	get_block_limits (const Arg &arg, const Limit &limit, const Limits &...limits)
template<bool is_offset, std::size_t... indices, typename Arg , typename Limit_tup , std::size_t... arg_ix, std::size_t... limits_ix>
constexpr auto	expand_block_limits (std::index_sequence< arg_ix... >, std::index_sequence< limits_ix... >, const Arg &arg, const Limit_tup &limit_tup)
template<typename Arg , typename... Offset, typename... Extent, std::size_t... Ix>
constexpr auto	get_slice_impl (Arg &&arg, const std::tuple< Offset... > &offsets, const std::tuple< Extent... > &extents, std::index_sequence< Ix... > seq)
template<typename T , std::size_t... Is>
constexpr bool	zero_dimension_count_impl (std::index_sequence< Is... >)
template<typename T , Layout layout, typename Scalar , std::size_t... I, typename... Args>
auto	make_dense_object_from_impl (std::index_sequence< I... >, Args...args)
template<std::size_t... ixs, typename DTup , typename... Args>
constexpr void	check_n_ary_dims (std::index_sequence< ixs... >, const DTup &d_tup, const Args &...args)
template<typename Op , typename... Args, std::size_t... I>
constexpr bool	is_invocable_with_indices (std::index_sequence< I... >)
template<typename Op , std::size_t... I, typename... Args>
decltype(auto) constexpr	n_ary_invoke_op (const Op &op, std::index_sequence< I... > seq, Args &&...args)
template<typename Arg , std::size_t... I, typename... J>
auto	n_ary_operation_get_component_impl (Arg &&arg, std::index_sequence< I... >, J...j)
template<typename Op , typename ArgsTup , std::size_t... ArgI, typename... J>
auto	n_ary_operation_get_component (const Op &op, ArgsTup &&args_tup, std::index_sequence< ArgI... >, J...j)
template<typename M , typename Op , typename ArgsTup , typename... J>
void	n_ary_operation_iterate (M &m, const Op &op, ArgsTup &&args_tup, std::index_sequence<>, J...j)
template<typename M , typename Op , typename ArgsTup , std::size_t I, std::size_t... Is, typename... J>
void	n_ary_operation_iterate (M &m, const Op &op, ArgsTup &&args_tup, std::index_sequence< I, Is... >, J...j)
template<std::size_t ix, typename Arg , typename... Args>
constexpr auto	find_max_dim (const Arg &arg, const Args &...args)
template<std::size_t... ixs, typename... Args>
constexpr auto	find_max_dims (std::index_sequence< ixs... >, const Args &...args)
template<typename M , typename Operation , typename Vs_tuple , typename Index_seq , typename K_seq , typename... Is>
void	nullary_set_components (M &m, const Operation &op, const Vs_tuple &, Index_seq, K_seq, Is...is)
template<std::size_t DsIndex, std::size_t... DsIndices, typename M , typename Operation , typename Vs_tuple , std::size_t... indices, std::size_t... Ks, typename... Is>
void	nullary_set_components (M &m, const Operation &op, const Vs_tuple &ds_tup, std::index_sequence< indices... > index_seq, std::index_sequence< Ks... > k_seq, Is...is)
template<std::size_t CurrentOpIndex, std::size_t factor, typename M , typename Operations_tuple , typename Vs_tuple , typename UniqueIndicesSeq , std::size_t... AllDsIndices, typename K_seq >
void	nullary_iterate (M &m, const Operations_tuple &op_tup, const Vs_tuple &ds_tup, UniqueIndicesSeq unique_indices_seq, std::index_sequence< AllDsIndices... >, K_seq k_seq)
template<std::size_t CurrentOpIndex, std::size_t factor, std::size_t index, std::size_t... indices, typename M , typename Operations_tuple , typename Vs_tuple , typename UniqueIndicesSeq , typename AllDsSeq , std::size_t... Ks, std::size_t... Js, typename... J_seqs>
void	nullary_iterate (M &m, const Operations_tuple &op_tup, const Vs_tuple &ds_tup, UniqueIndicesSeq unique_indices_seq, AllDsSeq all_ds_seq, std::index_sequence< Ks... >, std::index_sequence< Js... >, J_seqs...j_seqs)
template<typename Operation , typename Elem , typename... J>
void	do_elem_operation_in_place_impl (const Operation &operation, Elem &elem, J...j)
template<typename Operation , typename Arg , typename... J>
void	do_elem_operation_in_place (const Operation &operation, Arg &arg, J...j)
template<typename Operation , typename Arg , typename Count , typename... J>
void	unary_operation_in_place_impl (const Operation &operation, Arg &arg, const Count &count, J...j)
template<typename G , typename D >
	RandomizeOp (G &, D &&) -> RandomizeOp< G, D >
template<std::size_t index_to_delete, std::size_t... new_indices>
constexpr auto	delete_reduction_index (std::index_sequence<>)
template<std::size_t index_to_delete, std::size_t... new_indices, std::size_t index, std::size_t... indices>
constexpr auto	delete_reduction_index (std::index_sequence< index, indices... >)
template<typename BinaryOperation , typename Constant , typename Dim >
constexpr auto	constant_reduce_operation (const BinaryOperation &op, const Constant &c, const Dim &dim)
template<typename BinaryFunction , typename Arg , std::size_t... indices, std::size_t... Ix>
decltype(auto) constexpr	reduce_impl (BinaryFunction &&b, Arg &&arg, std::index_sequence< indices... > indices_seq, std::index_sequence< Ix... > seq)
template<std::size_t >
constexpr auto	chip_index_match ()
template<std::size_t ai, std::size_t index, std::size_t... indices, typename I , typename... Is>
constexpr auto	chip_index_match (I i, Is...is)
template<std::size_t... indices, typename Arg , typename Chip , std::size_t... all_indices, typename... Is>
constexpr Arg &	set_chip_impl (Arg &&arg, Chip &&chip, std::index_sequence< all_indices... >, Is...is)
template<typename Arg , typename Indices >
constexpr Arg &&	set_component_impl (Arg &&arg, const scalar_type_of_t< Arg > &s, const Indices &indices)
template<typename A , typename B >
void	solve_check_A_and_B_rows_match (const A &a, const B &b)
template<typename A , typename B , typename Arg >
decltype(auto)	wrap_solve_result_impl (Arg &&arg)
template<typename A , typename B , typename Arg >
decltype(auto)	wrap_solve_result (Arg &&arg)
template<std::size_t index, typename Arg , typename... Ds>
constexpr void	check_split_vector_space_descriptor (Arg &&arg, Ds &&...ds)
template<std::size_t index>
constexpr auto	split_dummy (std::size_t x)
template<std::size_t... indices, typename Arg , typename Blocks_tup >
auto	split_symmetric (Arg &&arg, std::size_t begin, Blocks_tup &&blocks_tup)
template<std::size_t... indices, typename Arg , typename Blocks_tup , typename D , typename... Ds>
auto	split_symmetric (Arg &&arg, std::size_t begin, Blocks_tup &&blocks_tup, D &&d, Ds &&...ds)
template<std::size_t index, std::size_t index_ix, typename Arg , typename... Ds_tups>
constexpr void	check_split_vector_space_descriptor_tup_impl (Arg &&arg, Ds_tups &&...ds_tups)
template<std::size_t... indices, typename Arg , typename... Ds_tups, std::size_t... indices_ix>
constexpr void	check_split_vector_space_descriptor_tup (Arg &&arg, std::index_sequence< indices_ix... >, Ds_tups &&...ds_tups)
template<std::size_t... indices, typename Arg , typename Begin_tup , typename Blocks_tup , std::size_t... indices_ix>
auto	split_impl (Arg &&arg, Begin_tup begin_tup, Blocks_tup &&blocks_tup, std::index_sequence< indices_ix... >)
template<std::size_t... indices, typename Arg , typename Begin_tup , typename Blocks_tup , std::size_t... indices_ix, typename Ds_tup , typename... Ds_tups>
auto	split_impl (Arg &&arg, Begin_tup begin_tup, Blocks_tup &&blocks_tup, std::index_sequence< indices_ix... > seq, Ds_tup &&ds_tup, Ds_tups &&...ds_tups)
template<std::size_t... Ix, typename T0 , typename T1 >
constexpr auto	sum_constants (std::index_sequence< Ix... > seq, T0 &&t0, T1 &&t1)
template<typename T >
constexpr T &&	sum_impl (T &&t)
template<typename T0 , typename T1 , typename... Ts>
decltype(auto) constexpr	sum_impl (T0 &&t0, T1 &&t1, Ts &&...ts)
template<std::size_t direction, typename... Index, std::size_t... dims, typename Arg >
constexpr void	tile_impl (std::tuple< Index... > &current_position, std::tuple< Index... > &current_block_size, std::index_sequence< dims... >, Arg &arg)
template<std::size_t direction, typename... Index, std::size_t... dims, typename Arg , typename Block , typename... Blocks>
constexpr void	tile_impl (std::tuple< Index... > &current_position, std::tuple< Index... > &current_block_size, std::index_sequence< dims... > seq, Arg &arg, Block &&block, Blocks &&...blocks)
template<typename T , std::size_t... I>
constexpr auto	all_vector_space_descriptors_impl (const T &t, std::index_sequence< I... >)
template<typename T , std::size_t... I>
constexpr auto	all_vector_space_descriptors_impl (std::index_sequence< I... >)
template<typename T , std::size_t... I>
constexpr bool	get_wrappable_impl (const T &t, std::index_sequence< I... >)
template<std::size_t I, std::size_t... Is, typename T >
constexpr bool	is_one_dimensional_impl (std::index_sequence< I, Is... >, const T &t)
template<std::size_t count, typename T , std::size_t i = 0>
constexpr auto	get_best_square_index ()
template<std::size_t... Is, typename T >
constexpr auto	is_square_shaped_impl (std::index_sequence< Is... >, const T &t)
template<std::size_t N, std::size_t... Is, typename T >
constexpr bool	get_is_vector_impl (std::index_sequence< Is... >, const T &t)
template<typename T >
constexpr auto	get_tensor_order_of_impl (std::index_sequence<>, const T &t)
template<std::size_t I, std::size_t... Is, typename T >
constexpr auto	get_tensor_order_of_impl (std::index_sequence< I, Is... >, const T &t)
template<std::size_t... Is>
constexpr bool	vector_space_descriptors_match_impl (std::index_sequence< Is... >)
template<std::size_t... Is, typename T , typename... Ts>
constexpr bool	vector_space_descriptors_match_impl (std::index_sequence< Is... >, const T &t, const Ts &...ts)
constexpr bool	vector_space_descriptors_match_dyn_impl ()
template<typename T , typename... Ts>
constexpr bool	vector_space_descriptors_match_dyn_impl (const T &t, const Ts &...ts)
template<typename T , std::size_t... I>
constexpr std::size_t	dynamic_index_count_impl (std::index_sequence< I... >)
template<std::size_t i, typename T >
constexpr std::size_t	max_tensor_order_impl (std::size_t result=0)
template<typename OutputCoefficients , typename In >
auto	zero_hessian_impl ()

Variables
template<typename T , typename U , std::size_t... indices>
constexpr bool	concatenate_dimensions_match
template<typename T , typename... Ts>
constexpr bool	constant_concatenate_arguments = constant_concatenate_arguments_impl<T, void, Ts...>::value
template<typename Op , std::size_t Indices, typename... Args>
constexpr bool	n_ary_operator = n_ary_operator_impl<Op, Indices, void, Args...>::value

Detailed Description

T is an acceptable noise perturbation input to a tests.

Template Parameters

OutputCoefficients

The expected coefficients of the tests output.

Variable Documentation

concatenate_dimensions_match

template<typename T , typename U , std::size_t... indices>

constexpr bool OpenKalman::detail::concatenate_dimensions_match

Initial value:

=

      (concatenate_dimensions_match_impl<T, U, indices...>(std::make_index_sequence<index_count_v<T>> {}))