OpenKalman::detail Namespace Reference

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

Classes
struct	compatible_shape_with_impl
struct	compatible_shape_with_impl< P, T, a, std::index_sequence< i... > >
struct	compatible_shape_with_impl_cpp17
struct	compatible_shape_with_impl_cpp17< P, T, a, std::enable_if_t< coordinates::pattern_collection< P > and indexible< T > and collections::size_of< P >::value !=stdex::dynamic_extent > >
struct	constant_concatenate_arguments_impl
struct	constant_concatenate_arguments_impl< T, std::enable_if_t<(values::internal::near(constant_value< T >::value, constant_value< Ts >::value) and ...)>, Ts... >
struct	constant_element_is_0_ep
struct	constant_element_is_0_ep< T, epsilon_factor, std::enable_if_t< values::fixed_value_compares_with< typename element_type_of< T >::type, 0, &stdex::is_eq, epsilon_factor > > >
struct	EigenWrapperEvaluatorBase
struct	EigenWrapperEvaluatorBase< XprType, Nested, std::enable_if_t< OpenKalman::Eigen3::eigen_dense_general< Nested > > >
struct	element_type_is_fixed
struct	element_type_is_fixed< T, std::enable_if_t< values::fixed< typename element_type_of< T >::type > > >
struct	FactorIs1
struct	FactorIs1< Factor, std::enable_if_t< Factor::value==1 > >
struct	hermitian_adapter_impl
struct	hermitian_adapter_impl< T, t, std::enable_if_t<(t==HermitianAdapterType::any ? interface::object_traits< stdex::remove_cvref_t< T >>::hermitian_adapter_type==HermitianAdapterType::lower or interface::object_traits< stdex::remove_cvref_t< T >>::hermitian_adapter_type==HermitianAdapterType::upper :interface::object_traits< stdex::remove_cvref_t< T >>::hermitian_adapter_type==t)> >
struct	index_collection_for_impl
struct	index_collection_for_impl< Indices, Indexible, std::enable_if_t< values::fixed_value_compares_with< collections::size_of< Indices >, stdex::dynamic_extent, &stdex::is_neq > > >
struct	index_collection_for_iter
struct	index_collection_for_iter< Indices, T, std::index_sequence< ix... > >
struct	is_cholesky_form
struct	is_cholesky_form< T, std::enable_if_t< covariance< T > > >
struct	is_dynamic_dimension
struct	is_dynamic_dimension< T, N, std::enable_if_t< indexible< T > and index_dimension_of< T, N >::value==stdex::dynamic_extent > >
struct	is_element_copyable
struct	is_element_copyable< To, From, std::enable_if_t< stdex::assignable_from< typename std::decay_t< decltype(get_mdspan(std::declval< To >()))>::reference, typename element_type_of< From >::type > > >
struct	is_explicitly_hermitian
struct	is_explicitly_hermitian< T, std::enable_if_t< interface::object_traits< stdex::remove_cvref_t< T > >::is_hermitian > >
struct	is_explicitly_square
struct	is_explicitly_square< T, b, std::enable_if_t< interface::object_traits< stdex::remove_cvref_t< T > >::template is_square< b > > >
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< constant_diagonal_object< T > and values::fixed_value_compares_with< decltype(constant_value(std::declval< T & >())), 1 > > >
struct	is_inferred_hermitian_matrix
struct	is_inferred_hermitian_matrix< T, std::enable_if_t< values::not_complex< typename element_type_of< T >::type > > >
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_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::object_traits< stdex::remove_cvref_t< T > >::is_triangular_adapter > >
struct	is_wrappable
struct	is_zero_constant
struct	is_zero_constant< T, epsilon_factor, std::enable_if_t< values::fixed_value_compares_with< decltype(interface::object_traits< stdex::remove_cvref_t< T >>::get_constant(std::declval< T >())), 0, &stdex::is_eq, epsilon_factor > > >
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 element_type_of< Args >::type >::type... >::value or is_invocable_with_indices< Op, typename std::add_lvalue_reference< typename element_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	pattern_mch
struct	pattern_mch< std::enable_if_t< patterns_may_match_with_impl< decltype(get_pattern_collection(std::declval< Ts >()))... >::value >, Ts... >
struct	pattern_mchx
struct	pattern_mchx< std::enable_if_t< patterns_match_with_impl< decltype(get_pattern_collection(std::declval< Ts >()))... >::value >, Ts... >
struct	patterns_match_with_impl
struct	patterns_match_with_impl< P, Ps... >
struct	patterns_may_match_with_impl
struct	patterns_may_match_with_impl< P, Ps... >
struct	RandomizeGenerator
struct	RandomizeOp
struct	transpose_layout
struct	triangle_type_of_impl
struct	triangle_type_of_impl< T, std::void_t< decltype(interface::object_traits< stdex::remove_cvref_t< T >>::triangle_type_value)> >
struct	value >=1)> >
struct	zero_dimension_count

Functions
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... is>
constexpr auto	empty_object_fixed_index_count (std::index_sequence< is... >)
template<typename T , std::enable_if_t< indexible< T >, int > = 0>
constexpr auto	empty_object_impl ()
template<typename T , applicability b, std::size_t... is>
constexpr auto	one_dimensional_fixed_index_count (std::index_sequence< is... >)
template<typename T , applicability b>
constexpr auto	one_dimensional_impl ()
template<typename T , std::size_t i>
constexpr std::size_t	best_square_index ()
template<typename T , applicability b, std::size_t... is>
constexpr auto	square_shaped_fixed_index_count (std::index_sequence< is... >)
template<typename T , applicability b>
constexpr auto	square_shaped_impl ()
template<typename T , std::size_t N, applicability b, std::size_t... is>
constexpr auto	vector_fixed_index_count (std::index_sequence< is... >)
template<typename T , std::size_t N, applicability b>
constexpr auto	vector_impl ()
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<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<std::size_t N, std::size_t i = 0, std::size_t... SDs, typename P , typename... Ds>
constexpr auto	derive_extents (const P &p, Ds...ds)
template<typename T , std::size_t... Is>
constexpr bool	zero_dimension_count_impl (std::index_sequence< Is... >)
template<typename T , typename 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 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 C , typename Arg , std::size_t... Is>
decltype(auto) constexpr	transpose_constant (C &&c, Arg &&arg, std::index_sequence< Is... >)
template<typename Indices , std::size_t... i>
decltype(auto) constexpr	make_index_array (const Indices &indices, std::index_sequence< i... >)
template<std::size_t i, typename Indices >
constexpr std::size_t	get_index (const Indices &indices, std::size_t s)
template<typename Indices , std::size_t... i>
decltype(auto) constexpr	make_index_array_padded (const Indices &indices, std::size_t s, std::index_sequence< i... >)
template<typename Mdspan , std::size_t i = Mdspan::rank()>
constexpr auto	remove_trailing_1D_indices ()
template<typename T , std::size_t... I>
constexpr std::size_t	dynamic_index_count_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 = 0, typename T >
constexpr bool	is_one_dimensional_impl (const T &t)
template<typename T , std::size_t i>
constexpr std::size_t	get_best_square_index ()
template<typename T , std::size_t... is>
constexpr auto	is_square_shaped_impl (const T &t, std::index_sequence< is... >)
template<std::size_t N, std::size_t i = 0, typename T >
constexpr bool	get_is_vector_impl (const T &t)
template<std::size_t i, typename T >
constexpr std::size_t	max_tensor_order_impl (std::size_t result=0)
template<std::size_t... Is>
constexpr bool	patterns_match_impl (std::index_sequence< Is... >)
template<std::size_t... Is, typename T , typename... Ts>
constexpr bool	patterns_match_impl (std::index_sequence< Is... >, const T &t, const Ts &...ts)
constexpr bool	patterns_match_dyn_impl ()
template<typename T , typename... Ts>
constexpr bool	patterns_match_dyn_impl (const T &t, const Ts &...ts)
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<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>> {}))