OpenKalman Namespace Reference

The root namespace for OpenKalman. More...

Namespaces
	collections
	Namespace for collections.
	coordinates
	The namespace for features relating to coordinates::pattern object.
	detail
	T is an acceptable noise perturbation input to a tests.
	values
	Definition for values::abs.

Classes
struct	constant_adapter
	A tensor or other matrix in which all elements are a constant value. More...
struct	constant_value_of
	The static constant value of an indexible object, if it exists. More...
struct	constant_value_of< T, std::enable_if_t< values::fixed< decltype(constant_value(std::declval< T >()))> > >
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
struct	ContinuousPropertyParticleDistribution
struct	Covariance
	A self-adjoint Covariance matrix. More...
struct	CubaturePoints
	Implementation of a cubature points transform. More...
struct	diagonal_adapter
	An adapter for creating a diagonal matrix or tensor. More...
struct	DistributionTraits< GaussianDistribution< Coeffs, NestedMean, NestedCovariance, re > >
struct	dynamic_index_count
	Counts the number of indices of T in which the dimensions are dynamic. More...
struct	dynamic_index_count< T, std::enable_if_t< indexible< T > > >
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
struct	element_type_of
	The element type (e.g., std::float, std::double, std::complex<double>) of an indexible object. More...
struct	element_type_of< T, std::enable_if_t< indexible< T > > >
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
struct	EuclideanMean
	Similar to a Mean, but the coefficients are transformed into Euclidean space, based on their type. More...
struct	FiniteDifferenceLinearization
	A tests which calculates the first and second Taylor derivatives using finite differences. More...
struct	FromEuclideanExpr
	An expression that transforms angular or other modular vector space descriptors back from Euclidean space. More...
struct	GaussianDistribution
	A Gaussian distribution, defined in terms of a Mean and a Covariance. More...
struct	hermitian_adapter_type_of
	The triangle_type associated with the storage triangle of one or more matrices. More...
struct	HermitianAdapter
	A hermitian matrix wrapper. More...
struct	IdentityTransform
	An identity transform from one statistical distribution to another. More...
struct	IdentityTransformation
struct	index_count
	The minimum number of indices needed to access all the components of an object (i.e., the rank or order). More...
struct	index_count< T, std::enable_if_t< values::fixed< decltype(count_indices(std::declval< const T & >()))> > >
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
struct	index_dimension_of
	The dimension of an index for a matrix, expression, or array. More...
struct	index_dimension_of< T, N, std::enable_if_t< indexible< T > > >
struct	KalmanFilter
	A Kalman filter, using one or more statistical transforms. More...
struct	KalmanFilter< ProcessTransform, MeasurementTransform >
	A Kalman filter, using a different statistical transform for the process and the measurement. More...
struct	KalmanFilter< Transform >
	A Kalman filter, using the same transform for the process and the measurement. More...
struct	layout_of
	The layout_mapping_policy of an indexible object. More...
struct	layout_of< T, std::enable_if_t< indexible< T > > >
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
class	LinearizedTransform
	A linearized transform, using a 1st or 2nd order Taylor approximation of a linear tests. More...
class	LinearTransform
	A linear tests from one statistical distribution to another. More...
struct	LinearTransformation
	A linear tests from one single-column vector to another. More...
struct	Matrix
	A matrix with typed rows and columns. More...
struct	max_tensor_order
	The maximum number of indices of structure T of size other than 1 (including any dynamic indices). More...
struct	max_tensor_order< T, std::enable_if_t< index_count< T >::value !=stdex::dynamic_extent > >
struct	Mean
	A set of one or more column vectors, each representing a statistical mean. More...
struct	MixtureOfContinuousDistributions
	Weighted mixture of continuous (e.g., Gaussian) distributions. More...
struct	MonteCarloTransform
	A Monte Carlo transform from one Gaussian distribution to another. More...
struct	nested_object_of
	A wrapper type's nested object type, if it exists. More...
struct	nested_object_of< T, std::enable_if_t< has_nested_object< T > > >
struct	ParticleDistribution
	Distribution of particles. More...
struct	ParticleFilter
struct	pattern_adapter
	An adapter that attaches a pattern_collection to an indexible object. More...
struct	RecursiveLeastSquaresTransform
	Propagates a recursive least squares error distribution of parameters, with a forgetting factor λ. More...
struct	SamplePointsTransform
	Scaled points transform. More...
struct	SphericalSimplex
	Spherical simplex sigma points, as implemented in, e.g., Simon J. More...
struct	SphericalSimplexParameters
struct	SquareRootCovariance
	The upper or lower triangle Cholesky factor (square root) of a covariance matrix. More...
struct	ToEuclideanExpr
	An expression that transforms vector space descriptors into Euclidean space for application of directional statistics. More...
struct	Transformation
	A tests from one single-column vector to another. More...
struct	Transformation< Function >
struct	Transformation< Function, JacobianFunction >
struct	Transformation< Function, JacobianFunction, HessianFunction >
struct	triangle_type_of
	The triangle_type associated with an indexible object. More...
struct	TriangularAdapter
	A triangular_adapter, where components above or below the diagonal (or both) are zero. More...
struct	Unscented
	Scaled symmetric sigma points. More...
struct	UnscentedParametersParameterEstimation
	Unscented parameters for use in parameter estimation. More...
struct	UnscentedParametersStateEstimation
	Unscented parameters for use in state estimation (the default). More...
struct	WeightedParticleDistribution

Typedefs
template<typename Shape , typename N = element_type_of_t<Shape>>
using	zero_adapter = constant_adapter< values::fixed_value< N, 0 >, Shape >
	A constant_adapter in which all elements are 0. More...
template<typename T , data_layout layout = data_layout::none, typename S = scalar_type_of_t<T>, typename D = decltype(all_vector_space_descriptors(std::declval<T>())), std::enable_if_t< indexible< T > and values::number< S > and pattern_collection< D >, int > = 0>
using	dense_writable_matrix_t = std::decay_t< decltype(make_dense_object< T, layout, S >(std::declval< D >()))>
	An alias for a dense, writable matrix, patterned on parameter T. More...
template<typename T >
using	element_type_of_t = typename element_type_of< T >::type
	helper template for element_type_of.
template<typename T >
using	layout_of_t = typename layout_of< T >::type
	helper template for layout_of.
template<typename T >
using	nested_object_of_t = typename nested_object_of< T >::type
	Helper type for nested_object_of. More...
using	SphericalSimplexSigmaPoints = SphericalSimplex< SphericalSimplexParameters >
using	UnscentedSigmaPointsStateEstimation = Unscented< UnscentedParametersStateEstimation >
using	UnscentedSigmaPointsParameterEstimation = Unscented< UnscentedParametersParameterEstimation >
using	UnscentedSigmaPoints = Unscented< UnscentedParametersStateEstimation >
	Same as UnscentedSigmaPointsStateEstimation.
using	CubatureTransform = SamplePointsTransform< CubaturePoints >
using	UnscentedTransform = SamplePointsTransform< UnscentedSigmaPoints >
using	UnscentedTransformParameterEstimation = SamplePointsTransform< UnscentedSigmaPointsParameterEstimation >

Enumerations
enum	triangle_type : int {   triangle_type::none, triangle_type::any, triangle_type::lower, triangle_type::upper,   triangle_type::diagonal }
	The type of a triangular matrix. More...
enum	HermitianAdapterType : int { HermitianAdapterType::none = static_cast<int>(triangle_type::none), HermitianAdapterType::any = static_cast<int>(triangle_type::diagonal), HermitianAdapterType::lower = static_cast<int>(triangle_type::lower), HermitianAdapterType::upper = static_cast<int>(triangle_type::upper) }
	The type of a hermitian adapter, indicating which triangle of the nested matrix is used. More...
enum	applicability : int { applicability::guaranteed, applicability::permitted }
	The applicability of a concept, trait, or restraint. More...

Functions
constexpr std::size_t	operator""_uz (unsigned long long x)
template<typename M , typename C , std::enable_if_t< typed_matrix< M > and self_adjoint_covariance< C >, int > = 0>
	GaussianDistribution (M &&, C &&) -> GaussianDistribution< vector_space_descriptor_of_t< M, 0 >, nested_object_of_t< passable_t< M >>, nested_object_of_t< passable_t< C >>>
template<typename D , std::enable_if_t< gaussian_distribution< D >, int > = 0>
auto	make_GaussianDistribution (D &&dist)
	Make a Gaussian distribution. More...
template<typename re = std::mt19937, typename M , typename Cov >
auto	make_GaussianDistribution (M &&mean, Cov &&cov)
	Make a Gaussian distribution. More...
template<typename re = std::mt19937, typename M , typename Cov , std::enable_if_t<(not fixed_pattern< re >) and typed_matrix< M > and vector< M > and has_untyped_index< M, 1 > and square_shaped< Cov > and(covariance_nestable< Cov > or typed_matrix_nestable< Cov >) and(index_dimension_of< M, 0 >::value==index_dimension_of< Cov, 0 >::value), int > = 0>
auto	make_GaussianDistribution (M &&mean, Cov &&cov)
	Make a Gaussian distribution. More...
template<typename StaticDescriptor , typename re = std::mt19937, typename M , typename Cov , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< M > and vector< M > and(covariance_nestable< Cov > or typed_matrix_nestable< Cov >), int > = 0>
auto	make_GaussianDistribution (M &&mean, Cov &&cov)
	Make a Gaussian distribution. More...
template<typename M , typename Cov , typename re = std::mt19937, std::enable_if_t< typed_matrix< M > and vector< M > and has_untyped_index< M, 1 > and covariance< Cov > and compares_with< vector_space_descriptor_of_t< M, 0 >, vector_space_descriptor_of_t< Cov, 0 >>, int > = 0>
auto	make_GaussianDistribution ()
	Make a default Gaussian distribution. More...
template<typename StaticDescriptor , typename M , typename Cov , typename re = std::mt19937, std::enable_if_t< typed_matrix_nestable< M > and vector< M > and covariance_nestable< Cov > and(index_dimension_of< M, 0 >::value==index_dimension_of< Cov, 0 >::value), int > = 0>
auto	make_GaussianDistribution ()
	Make a default Gaussian distribution. More...
template<typename Arg , std::enable_if_t< gaussian_distribution< Arg >, int > = 0>
decltype(auto) constexpr	mean_of (Arg &&arg)
template<typename Arg , std::enable_if_t< gaussian_distribution< Arg >, int > = 0>
decltype(auto) constexpr	covariance_of (Arg &&arg)
template<typename T , std::size_t dimension = index_dimension_of<T, 0>::value, typename Scalar = typename scalar_type_of<T>::type, typename... runtime_dimensions, std::enable_if_t< gaussian_distribution< T > and(sizeof...(runtime_dimensions)==(dimension==stdex::dynamic_extent ? 1 :0)) and(stdex::convertible_to< runtime_dimensions, std::size_t > and ...), int > = 0>
constexpr auto	make_zero_distribution_like (runtime_dimensions...e)
template<typename T , std::size_t dimension = index_dimension_of<T, 0>::value, typename Scalar = typename scalar_type_of<T>::type, typename... runtime_dimensions, std::enable_if_t< gaussian_distribution< T > and(sizeof...(runtime_dimensions)==(dimension==stdex::dynamic_extent ? 1 :0)) and(stdex::convertible_to< runtime_dimensions, std::size_t > and ...), int > = 0>
constexpr auto	make_normal_distribution_like (runtime_dimensions...e)
template<typename D , typename ... Ds, std::enable_if_t<(gaussian_distribution< D > and ... and gaussian_distribution< Ds >), int > = 0>
auto	concatenate (D &&d, Ds &&... ds)
template<typename ... Cs, typename D , std::enable_if_t<(fixed_pattern< Cs > and ...) and gaussian_distribution< D > and coordinates::compares_with< static_concatenate_t< Cs... >, typename DistributionTraits< D >::StaticDescriptor, less_equal<>>, int > = 0>
auto	split (D &&d)
	Split distribution.
template<typename Dist , std::enable_if_t< gaussian_distribution< Dist >, int > = 0>
std::ostream &	operator<< (std::ostream &os, const Dist &d)
template<typename Dist1 , typename Dist2 , std::enable_if_t< gaussian_distribution< Dist1 > and gaussian_distribution< Dist2 > and coordinates::compares_with< typename DistributionTraits< Dist1 >::StaticDescriptor, typename DistributionTraits< Dist2 >::StaticDescriptor >, int > = 0>
auto	operator+ (Dist1 &&d1, Dist2 &&d2)
template<typename Dist1 , typename Dist2 , std::enable_if_t< gaussian_distribution< Dist1 > and gaussian_distribution< Dist2 > and coordinates::compares_with< typename DistributionTraits< Dist1 >::StaticDescriptor, typename DistributionTraits< Dist2 >::StaticDescriptor >, int > = 0>
auto	operator- (Dist1 &&d1, Dist2 &&d2)
template<typename A , typename D , std::enable_if_t< typed_matrix< A > and gaussian_distribution< D > and(not euclidean_transformed< A >) and(compares_with< vector_space_descriptor_of_t< A, 1 >, typename DistributionTraits< D >::StaticDescriptor >), int > = 0>
auto	operator* (A &&a, D &&d)
template<typename Dist , typename S , std::enable_if_t< gaussian_distribution< Dist > and stdex::convertible_to< S, const typename DistributionTraits< Dist >::Scalar >, int > = 0>
auto	operator* (Dist &&d, S s)
template<typename Dist , typename S , std::enable_if_t< gaussian_distribution< Dist > and stdex::convertible_to< S, const typename DistributionTraits< Dist >::Scalar >, int > = 0>
auto	operator* (S s, Dist &&d)
template<typename Dist , typename S , std::enable_if_t< gaussian_distribution< Dist > and std::is_convertible_v< S, const typename DistributionTraits< Dist >::Scalar >, int > = 0>
auto	operator/ (Dist &&d, S s)
template<typename P >
	KalmanFilter (P &&) -> KalmanFilter< P >
template<typename P , typename M >
	KalmanFilter (P &&, M &&) -> KalmanFilter< P, M >
template<typename C , typename Arg , std::enable_if_t< values::scalar< C > and indexible< Arg >, int > = 0>
	constant_adapter (const C &, const Arg &) -> constant_adapter< C, Arg >
template<typename Arg , std::enable_if_t< constant_object< Arg > and(not is_constant_adapter< Arg >), int > = 0>
	constant_adapter (const Arg &) -> constant_adapter< is_constant_value< Arg >::value, Arg >
template<typename M , std::enable_if_t< covariance_nestable< M >, int > = 0>
	Covariance (M &&) -> Covariance< Dimensions< index_dimension_of_v< M, 0 >>, passable_t< M >>
	Deduce Covariance type from a covariance_nestable. More...
template<typename StaticDescriptor , typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and covariance_nestable< Arg > and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< Arg, 0 >::value), int > = 0>
auto	make_covariance (Arg &&arg)
	Make a Covariance from a covariance_nestable, specifying the fixed_pattern. More...
template<typename StaticDescriptor , triangle_type tri, typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and covariance_nestable< Arg > and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< Arg, 0 >::value) and(tri !=triangle_type::lower or triangular_matrix< Arg, triangle_type::lower >) and(tri !=triangle_type::upper or triangular_matrix< Arg, triangle_type::upper >) and(tri !=triangle_type::diagonal or diagonal_matrix< Arg >), int > = 0>
auto	make_covariance (Arg &&arg)
	Make a Covariance from a covariance_nestable, specifying the fixed_pattern. More...
template<typename Arg , std::enable_if_t< covariance_nestable< Arg >, int > = 0>
auto	make_covariance (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename StaticDescriptor , typename Arg , std::enable_if_t<(covariance_nestable< Arg > or typed_matrix_nestable< Arg >) and square_shaped< Arg >, int > = 0>
auto	make_covariance ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename StaticDescriptor , triangle_type tri, typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< Arg > and square_shaped< Arg >, int > = 0>
auto	make_covariance ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , std::enable_if_t<(covariance_nestable< Arg > or typed_matrix_nestable< Arg >) and square_shaped< Arg >, int > = 0>
auto	make_covariance ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg1 , typename Arg2 , std::enable_if_t<((covariance< Arg1 > and(covariance< Arg2 > or(typed_matrix< Arg2 > and square_shaped< Arg2 >))) or((typed_matrix< Arg1 > and square_shaped< Arg1 >) and covariance< Arg2 >)) and compares_with< vector_space_descriptor_of_t< Arg1, 0 >, vector_space_descriptor_of_t< Arg2, 0 >>, int > = 0>
decltype(auto) constexpr	operator+ (Arg1 &&arg1, Arg2 &&arg2)
template<typename Arg1 , typename Arg2 , std::enable_if_t<((covariance< Arg1 > and(covariance< Arg2 > or(typed_matrix< Arg2 > and square_shaped< Arg2 >))) or((typed_matrix< Arg1 > and square_shaped< Arg1 >) and covariance< Arg2 >)) and compares_with< vector_space_descriptor_of_t< Arg1, 0 >, vector_space_descriptor_of_t< Arg2, 0 >>, int > = 0>
decltype(auto) constexpr	operator- (Arg1 &&arg1, Arg2 &&arg2)
template<typename Arg1 , typename Arg2 , std::enable_if_t< covariance< Arg1 > and covariance< Arg2 > and compares_with< vector_space_descriptor_of_t< Arg1, 0 >, vector_space_descriptor_of_t< Arg2, 0 >>, int > = 0>
decltype(auto) constexpr	operator* (Arg1 &&arg1, Arg2 &&arg2)
template<typename M , typename Cov , std::enable_if_t< typed_matrix< M > and covariance< Cov > and compares_with< vector_space_descriptor_of_t< M, 0 >::ColumnCoefficients, typename MatrixTraits< std::decay_t< Cov >>>, int > = 0>
decltype(auto) constexpr	operator* (M &&m, Cov &&cov)
template<typename Cov , typename M , std::enable_if_t< covariance< Cov > and typed_matrix< M > and compares_with< vector_space_descriptor_of_t< Cov, 0 >, vector_space_descriptor_of_t< M, 0 >>, int > = 0>
decltype(auto) constexpr	operator* (Cov &&cov, M &&m)
template<typename M , typename S , std::enable_if_t< covariance< M > and stdex::convertible_to< S, typename scalar_type_of< M >::type >, int > = 0>
auto	operator* (M &&m, const S s)
template<typename S , typename M , std::enable_if_t< stdex::convertible_to< S, typename scalar_type_of< M >::type > and covariance< M >, int > = 0>
auto	operator* (const S s, M &&m)
template<typename M , typename S , std::enable_if_t< covariance< M > and stdex::convertible_to< S, typename scalar_type_of< M >::type >, int > = 0>
constexpr auto	operator/ (M &&m, const S s)
template<typename M , std::enable_if_t< covariance< M >, int > = 0>
constexpr auto	operator- (M &&m)
template<typename Arg1 , typename Arg2 , std::enable_if_t< covariance< Arg1 > and covariance< Arg2 >, int > = 0>
constexpr bool	operator== (Arg1 &&arg1, Arg2 &&arg2)
template<typename Arg1 , typename Arg2 , std::enable_if_t< covariance< Arg1 > and covariance< Arg2 >, int > = 0>
constexpr bool	operator!= (Arg1 &&arg1, Arg2 &&arg2)
template<typename M , typename S , std::enable_if_t< covariance< M > and stdex::convertible_to< S, typename scalar_type_of< M >::type >, int > = 0>
auto	scale (M &&m, const S s)
	Scale a covariance by a factor. More...
template<typename M , typename S , std::enable_if_t< covariance< M > and stdex::convertible_to< S, typename scalar_type_of< M >::type >, int > = 0>
auto	inverse_scale (M &&m, const S s)
	Scale a covariance by the inverse of a scalar factor. More...
template<typename M , typename A , std::enable_if_t< covariance< M > and typed_matrix< A > and compares_with< vector_space_descriptor_of_t< A, 0 >::ColumnCoefficients, typename MatrixTraits< std::decay_t< M >>>and(not euclidean_transformed< A >), int > = 0>
auto	scale (M &&m, A &&a)
	Scale a covariance by a matrix. More...
template<typename Arg , std::enable_if_t< self_adjoint_covariance< Arg >, int > = 0>
auto	square_root (Arg &&arg)
template<typename Arg , std::enable_if_t< triangular_covariance< Arg >, int > = 0>
auto	square (Arg &&arg)
template<typename M , typename ... Ms, std::enable_if_t<(covariance< M > and ... and covariance< Ms >), int > = 0>
decltype(auto) constexpr	concatenate (M &&m, Ms &&... mN)
	Concatenate one or more Covariance or SquareRootCovariance objects diagonally.
template<typename ... Cs, typename M , std::enable_if_t< covariance< M >, int > = 0>
auto	split_diagonal (M &&m)
	Split Covariance or SquareRootCovariance diagonally. More...
template<typename ... Cs, typename M , std::enable_if_t< covariance< M >, int > = 0>
auto	split_vertical (M &&m)
	Split Covariance or SquareRootCovariance vertically. Result is a tuple of typed matrices. More...
template<typename ... Cs, typename M , std::enable_if_t< covariance< M >, int > = 0>
auto	split_horizontal (M &&m)
	Split Covariance or SquareRootCovariance vertically. Result is a tuple of typed matrices. More...
template<typename Function , typename Arg , std::enable_if_t< covariance< Arg > and typed_matrix< std::invoke_result_t< Function, std::decay_t< decltype(column< 0 >(std::declval< Arg >()))>>>, int > = 0>
auto	apply_columnwise (const Function &f, Arg &&arg)
template<typename Function , typename Arg , std::enable_if_t< covariance< Arg > and stdex::convertible_to< std::invoke_result_t< Function, typename scalar_type_of< Arg >::type >, const typename scalar_type_of< Arg >::type >, int > = 0>
auto	apply_coefficientwise (const Function &f, Arg &&arg)
template<typename Cov , std::enable_if_t< covariance< Cov >, int > = 0>
std::ostream &	operator<< (std::ostream &os, const Cov &c)
template<typename V1 , typename V2 , std::enable_if_t< typed_matrix< V1 > and typed_matrix< V2 >, int > = 0>
auto	operator+ (V1 &&v1, V2 &&v2)
	Add two typed matrices. If the operands are of different types, the result will be a regular typed matrix.
template<typename V1 , typename V2 , std::enable_if_t< typed_matrix< V1 > and typed_matrix< V2 >, int > = 0>
auto	operator- (V1 &&v1, V2 &&v2)
	Subtract two typed matrices. The result is a regular typed matrix unless both operands are EuclideanMean.
template<typename V , typename S , std::enable_if_t< typed_matrix< V > and stdex::convertible_to< S, const typename scalar_type_of< V >::type >, int > = 0>
auto	operator* (V &&v, S scale)
	Multiply a typed matrix by a scalar. The result type is the same as the operand type, so angles in the result may be wrapped.
template<typename V , typename S , std::enable_if_t< typed_matrix< V > and stdex::convertible_to< S, const typename scalar_type_of< V >::type >, int > = 0>
auto	operator* (S scale, V &&v)
	Multiply a scalar by a typed matrix. The result type is the same as the operand type, so angles in the result may be wrapped.
template<typename V , typename S , std::enable_if_t< typed_matrix< V > and stdex::convertible_to< S, const typename scalar_type_of< V >::type >, int > = 0>
auto	operator/ (V &&v, S scale)
	Divide a typed matrix by a scalar. The result type is the same as the operand type, so angles in the result may be wrapped.
template<typename V1 , typename V2 , std::enable_if_t< typed_matrix< V1 > and typed_matrix< V2 >, int > = 0>
auto	operator* (V1 &&v1, V2 &&v2)
	Multiply a typed matrix by another typed matrix. The result is a regular typed matrix unless the first operand is EuclideanMean.
template<typename V , std::enable_if_t< typed_matrix< V >, int > = 0>
auto	operator- (V &&v)
	Negate a vector object. The result is a regular typed matrix unless the operand is EuclideanMean.
template<typename V1 , typename V2 , std::enable_if_t< typed_matrix< V1 > and typed_matrix< V2 >, int > = 0>
constexpr bool	operator== (V1 &&v1, V2 &&v2)
	typed_matrix == typed_matrix.
template<typename V1 , typename V2 , std::enable_if_t< typed_matrix< V1 > and typed_matrix< V2 >, int > = 0>
constexpr bool	operator!= (V1 &&v1, V2 &&v2)
	typed_matrix != typed_matrix.
template<typename V , typename ... Vs>
decltype(auto) constexpr	concatenate_vertical (V &&v, Vs &&... vs)
	Concatenate one or more typed matrices objects vertically.
template<typename ... Vs, std::enable_if_t<(typed_matrix< Vs > and ...), int > = 0>
decltype(auto) constexpr	concatenate (Vs &&... vs)
	Concatenate one or more typed matrices vertically. (Synonym for concatenate_vertical.)
template<typename V , typename ... Vs>
decltype(auto) constexpr	concatenate_horizontal (V &&v, Vs &&... vs)
	Concatenate one or more matrix objects vertically.
template<typename V , typename ... Vs, std::enable_if_t<(typed_matrix< V > and ... and typed_matrix< Vs >), int > = 0>
decltype(auto) constexpr	concatenate_diagonal (V &&v, Vs &&... vs)
	Concatenate one or more typed matrices diagonally.
template<typename Function , typename Arg >
Arg &	apply_columnwise (const Function &f, Arg &arg)
template<typename Function , typename Arg , std::enable_if_t< typed_matrix< Arg > and has_untyped_index< Arg, 1 > and typed_matrix< std::invoke_result_t< const Function &, std::decay_t< decltype(column(std::declval< const Arg &>(), 0))> && >>, int > = 0>
auto	apply_columnwise (const Function &f, const Arg &arg)
template<std::size_t count, typename Function , std::enable_if_t< typed_matrix< std::invoke_result_t< const Function &>>, int > = 0>
auto	apply_columnwise (const Function &f)
template<typename Function , typename Arg , std::enable_if_t< typed_matrix< Arg > and std::is_void_v< std::invoke_result_t< const Function &, std::decay_t< scalar_type_of_t< Arg >> &>>, int > = 0>
Arg &	apply_coefficientwise (const Function &f, Arg &arg)
template<typename Function , typename Arg , std::enable_if_t< typed_matrix< Arg > and stdex::convertible_to< std::invoke_result_t< const Function &, std::decay_t< typename scalar_type_of< Arg >::type >>, typename scalar_type_of< Arg >::type >, int > = 0>
auto	apply_coefficientwise (const Function &f, const Arg &arg)
template<typename V , typename Function , std::enable_if_t< typed_matrix< V > and stdex::convertible_to< std::invoke_result_t< const Function &>, typename scalar_type_of< V >::type >, int > = 0>
auto	apply_coefficientwise (const Function &f)
template<typename V , typename Function , std::enable_if_t< typed_matrix< V > and stdex::convertible_to< std::invoke_result_t< const Function &, std::size_t, std::size_t >, typename scalar_type_of< V >::type >, int > = 0>
auto	apply_coefficientwise (Function &&f)
template<typename ReturnType , typename random_number_engine = std::mt19937, typename... Dists, std::enable_if_t< typed_matrix< ReturnType > and(not has_dynamic_dimensions< ReturnType >) and(sizeof...(Dists) > 0>
auto	randomize (Dists &&... dists)
	Fill a fixed-shape typed matrix with random values selected from a random distribution. More...
template<typename ReturnType , typename random_number_engine = std::mt19937, typename Dist >
auto	randomize (const std::size_t rows, const std::size_t columns, Dist &&dist)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename V , std::enable_if_t< typed_matrix< V >, int > = 0>
std::ostream &	operator<< (std::ostream &os, const V &v)
	Output the vector to a stream.
template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>
	diagonal_adapter (Arg &&) -> diagonal_adapter< Arg >
	Deduce diagonal_adapter NestedObject from its constructor argument.
template<typename V , std::enable_if_t< typed_matrix< V > and not euclidean_transformed< V > and has_untyped_index< V, 1 > andcoordinates::stat_dimension_of_v< vector_space_descriptor_of_t< V, 0 >>==index_dimension_of_v< V, 0 >, int > = 0>
	EuclideanMean (V &&) -> EuclideanMean< vector_space_descriptor_of_t< V, 0 >, std::remove_reference_t< decltype(to_euclidean< vector_space_descriptor_of_t< V, 0 >>(nested_object(std::declval< V &&>())))>>
	Deduce template parameters from a non-Euclidean-transformed typed matrix. More...
template<typename StaticDescriptor , typename M , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< M > and(coordinates::stat_dimension_of_v< StaticDescriptor >==index_dimension_of< M, 0 >::value), int > = 0>
auto	make_euclidean_mean (M &&arg)
	Make a EuclideanMean from a typed_matrix_nestable, specifying the row coefficients. More...
template<typename M , std::enable_if_t< typed_matrix_nestable< M >, int > = 0>
auto	make_euclidean_mean (M &&m)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , std::enable_if_t< typed_matrix< Arg > and has_untyped_index< Arg, 1 >, int > = 0>
auto	make_euclidean_mean (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename StaticDescriptor , typename M , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< M > and(coordinates::stat_dimension_of_v< StaticDescriptor >==index_dimension_of< M, 0 >::value), int > = 0>
auto	make_euclidean_mean ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename M , std::enable_if_t< typed_matrix_nestable< M >, int > = 0>
auto	make_euclidean_mean ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , typename V , std::enable_if_t< indexible< Arg > and coordinates::pattern< V >, int > = 0>
	FromEuclideanExpr (Arg &&, const V &) -> FromEuclideanExpr< Arg, V >
template<typename M , std::enable_if_t< hermitian_matrix< M, applicability::permitted >, int > = 0>
	HermitianAdapter (M &&) -> HermitianAdapter< nested_object_of_t< M >, hermitian_adapter_type_of_v< M >>
	Deduction guide for converting Eigen::SelfAdjointView to HermitianAdapter.
template<typename M , std::enable_if_t< typed_matrix_nestable< M >, int > = 0>
	Matrix (M &&) -> Matrix< Dimensions< index_dimension_of_v< M, 0 >>, Dimensions< index_dimension_of_v< M, 1 >>, passable_t< M >>
	Deduce parameter types from a typed_matrix_nestable.
template<typename M , std::enable_if_t< typed_matrix_nestable< M >, int > = 0>
	Matrix (M &&, const Cs &...) -> Matrix< Cs..., passable_t< M >>
template<typename V , std::enable_if_t< typed_matrix< V > and not euclidean_transformed< V >, int > = 0>
	Matrix (V &&) -> Matrix< vector_space_descriptor_of_t< V, 0 >, vector_space_descriptor_of_t< V, 1 >, passable_t< nested_object_of_t< V >>>
	Deduce template parameters from a non-Euclidean-transformed typed matrix. More...
template<typename V , std::enable_if_t< typed_matrix_nestable< V >, int > = 0>
	Mean (V &&) -> Mean< Dimensions< index_dimension_of_v< V, 0 >>, passable_t< V >>
	Deduce template parameters from a typed_matrix_nestable, assuming untyped coordinates::pattern. More...
template<typename StaticDescriptor , typename M , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< M > and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< M, 0 >::value), int > = 0>
auto	make_mean (M &&m)
	Make a Mean from a typed_matrix_nestable, specifying the row fixed_pattern. More...
template<typename M , std::enable_if_t< typed_matrix_nestable< M >, int > = 0>
auto	make_mean (M &&m)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , std::enable_if_t< typed_matrix< Arg > and has_untyped_index< Arg, 1 >, int > = 0>
auto	make_mean (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename StaticDescriptor , typename M , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< M > and(index_dimension_of< M, 0 >::value==coordinates::dimension_of_v< StaticDescriptor >), int > = 0>
auto	make_mean ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename M , std::enable_if_t< typed_matrix_nestable< M >, int > = 0>
auto	make_mean ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , typename P , std::enable_if_t< indexible< Arg > and pattern_collection_for< P, Arg >, int > = 0>
	pattern_adapter (Arg &&, P &&) -> pattern_adapter< Arg, P >
	Deduction guide.
template<typename M , std::enable_if_t< covariance_nestable< M >, int > = 0>
	SquareRootCovariance (M &&) -> SquareRootCovariance< Dimensions< index_dimension_of_v< M, 0 >>, passable_t< M >>
	Deduce SquareRootCovariance type from a covariance_nestable. More...
template<typename StaticDescriptor , typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and covariance_nestable< Arg > and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< Arg, 0 >::value), int > = 0>
auto	make_square_root_covariance (Arg &&arg)
	Make a SquareRootCovariance from a covariance_nestable, specifying the coefficients. More...
template<typename Arg , std::enable_if_t< covariance_nestable< Arg >, int > = 0>
auto	make_square_root_covariance (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename StaticDescriptor , triangle_type tri = triangle_type::lower, typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< Arg > and(not covariance_nestable< Arg >) and(tri==triangle_type::lower or tri==triangle_type::upper) and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< Arg, 0 >::value) and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< Arg, 1 >::value), int > = 0>
auto	make_square_root_covariance (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename StaticDescriptor , triangle_type tri, typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< Arg > and square_shaped< Arg >, int > = 0>
auto	make_square_root_covariance ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename StaticDescriptor , typename Arg , std::enable_if_t<(covariance_nestable< Arg > or typed_matrix_nestable< Arg >) and square_shaped< Arg >, int > = 0>
auto	make_square_root_covariance ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , std::enable_if_t<(covariance_nestable< Arg > or typed_matrix_nestable< Arg >) and square_shaped< Arg >, int > = 0>
auto	make_square_root_covariance ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>
	ToEuclideanExpr (Arg &&) -> ToEuclideanExpr< Arg >
	Deduction guide.
template<typename M , std::enable_if_t< triangular_matrix< M >, int > = 0>
	TriangularAdapter (M &&) -> TriangularAdapter< std::conditional_t< triangular_adapter< M >, nested_object_of_t< M >, M >, triangle_type_of_v< M >>
constexpr triangle_type	operator* (triangle_type a, triangle_type b)
	The resulting triangle_type if two indexible objects, each having a triangle_type, are multiplied component-wise.
constexpr triangle_type	operator+ (triangle_type a, triangle_type b)
	The resulting triangle_type if two indexible objects, each having a triangle_type, are added component-wise.
template<std::size_t indexa = 0, std::size_t indexb = 1, typename Arg >
decltype(auto) constexpr	adjoint (Arg &&arg)
	Take the conjugate-transpose of an indexible_object. More...
template<typename Arg , typename P , std::enable_if_t< indexible< Arg > and pattern_collection_for< P, Arg >, int > = 0>
constexpr auto	attach_pattern (Arg &&arg, P &&p)
	Attach a pattern_collection to an indexible object. More...
template<typename Arg , typename... Ps, std::enable_if_t< indexible< Arg > and(... and coordinates::pattern< Ps >) and pattern_collection_for< std::tuple< Ps... >, Arg >, int > = 0>
constexpr auto	attach_pattern (Arg &&arg, Ps &&...ps)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename P , typename Arg , std::enable_if_t< indexible< Arg > and pattern_collection_for< P, Arg >, int > = 0>
constexpr auto	attach_pattern (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<std::size_t index, std::size_t... indices, typename Arg , std::enable_if_t< internal::has_uniform_patterns< Arg, index, indices... > and(not empty_object< Arg >), int > = 0>
decltype(auto) constexpr	average_reduce (Arg &&arg)
	Perform a partial reduction by taking the average along one or more indices. More...
template<typename Arg , std::enable_if_t< internal::has_uniform_patterns< Arg >, int > = 0>
constexpr scalar_type_of_t< Arg >	average_reduce (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , typename... Factors, std::enable_if_t< indexible< Arg > and(... and values::index< Factors >), int > = 0>
decltype(auto) constexpr	broadcast (Arg &&arg, const Factors &...factors)
	Broadcast an object by replicating it by factors specified for each index. More...
template<std::size_t... indices, typename Operation , typename... Args, std::enable_if_t<(indexible< Args > and ...) and(sizeof...(Args) > 0>
constexpr auto	chipwise_operation (const Operation &operation, Args &&...args)
	Perform a chipwise n-ary operation (n>0) on one or more indexible objects. More...
template<std::size_t... indices, typename Operation , typename... Is, std::enable_if_t<(values::index< Is > and ...) and(sizeof...(Is)==sizeof...(indices)), int > = 0>
constexpr auto	chipwise_operation (const Operation &operation, Is...is)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<triangle_type tri, typename A , std::enable_if_t< hermitian_matrix< A, applicability::permitted > and(tri !=triangle_type::diagonal or diagonal_matrix< A >), int > = 0>
decltype(auto) constexpr	cholesky_factor (A &&a)
	Take the Cholesky factor of a matrix. More...
template<typename A , std::enable_if_t< hermitian_matrix< A, applicability::permitted >, int > = 0>
decltype(auto) constexpr	cholesky_factor (A &&a)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename A , std::enable_if_t< triangular_matrix< A > and square_shaped< A, applicability::permitted >, int > = 0>
decltype(auto) constexpr	cholesky_square (A &&a)
	Take the Cholesky square of a triangular_matrix. More...
template<std::size_t... indices, typename Arg , typename... Args, std::enable_if_t<(sizeof...(indices) > 0>
decltype(auto) constexpr	concatenate (Arg &&arg, Args &&...args)
	Concatenate some number of objects along one or more indices. More...
template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>
decltype(auto) constexpr	conjugate (Arg &&arg)
	Take the complex conjugate of an indexible object. More...
template<typename A , typename B >
decltype(auto) constexpr	contract (A &&a, B &&b)
	Matrix multiplication of A * B.
template<bool on_the_right = true, typename A , typename B >
constexpr A &&	contract_in_place (A &&a, B &&b)
	In-place matrix multiplication of A * B, storing the result in A. More...
template<typename Source , typename Dest , std::enable_if_t< copyable_from< Dest, Source >, int > = 0>
decltype(auto) constexpr	copy_from (Dest &&dest, Source &&source)
	Copy elements from one object to another. More...
template<typename Arg >
constexpr auto	determinant (Arg &&arg)
	Take the determinant of a matrix. More...
template<typename Arg >
decltype(auto) constexpr	diagonal_of (Arg &&arg)
	Extract a column vector (or column slice for rank>2 tensors) comprising the diagonal elements. More...
template<typename layout layout = stdex::layout_right, typename Arg , typename... S, std::enable_if_t< indexible< Arg > and(values::number< S > and ...) and(std::same_as< layout, stdex::layout_right > or std::same_as< layout, stdex::layout_left >) and internal::may_hold_components< Arg, S... > and(sizeof...(S)==0 or interface::fill_components_defined_for< Arg, layout, std::add_lvalue_reference_t< Arg >, S... >), int > = 0>
Arg &&	fill_components (Arg &&arg, S...s)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , typename V , std::enable_if_t< coordinates::euclidean_pattern< vector_space_descriptor_of_t< Arg, 0 >> and coordinates::pattern< V >, int > = 0>
decltype(auto) constexpr	from_euclidean (Arg &&arg, const V &v)
	Project the Euclidean vector space associated with index 0 to coordinates::pattern v after applying directional statistics. More...
template<std::size_t... indices, typename Arg , typename... Ixs, std::enable_if_t< indexible< Arg > and(values::index< Ixs > and ...) and(sizeof...(indices)==sizeof...(Ixs)), int > = 0>
decltype(auto) constexpr	get_chip (Arg &&arg, Ixs...ixs)
	Extract a sub-array having rank less than the rank of the input object. More...
template<std::size_t... indices, typename Arg , typename... Offset, typename... Extent, std::enable_if_t< indexible< Arg > and(values::index< Offset > and ...) and(values::index< Extent > and ...) and(sizeof...(Offset)==sizeof...(Extent)) and internal::has_uniform_patterns< Arg, indices... > and(sizeof...(indices)==0 or sizeof...(indices)==sizeof...(Offset)), int > = 0>
decltype(auto) constexpr	get_slice (Arg &&arg, const std::tuple< Offset... > &offsets, const std::tuple< Extent... > &extents)
	Extract a slice from a matrix or tensor. More...
template<typename A , std::enable_if_t< indexible< A > and(not euclidean_transformed< A >), int > = 0>
decltype(auto) constexpr	LQ_decomposition (A &&a)
	Perform an LQ decomposition of matrix A=[L,0]Q, L is a lower-triangular matrix, and Q is orthogonal. More...
template<typename C , typename IndexType , std::size_t... Extents, std::enable_if_t< values::value< C >, int > = 0>
constexpr auto	make_constant (C c, stdex::extents< IndexType, Extents... > extents)
	Make an indexible object in which every element is a constant value. More...
template<typename C , typename P , std::enable_if_t< values::value< C > and coordinates::pattern_collection< P > and values::fixed< collections::size_of< P >>, int > = 0>
constexpr auto	make_constant (C c, P &&p)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename C , typename... Ps, std::enable_if_t< values::value< C > and(... and coordinates::pattern< Ps >), int > = 0>
constexpr auto	make_constant (C c, Ps &&...ps)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename C , typename P , std::enable_if_t< coordinates::pattern_collection< P > and values::value< C > and values::fixed< collections::size_of< P >>, int > = 0>
constexpr auto	make_constant (C c)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename C , typename IndexType , std::size_t... Extents, std::enable_if_t< values::value< C >, int > = 0>
constexpr auto	make_constant_diagonal (C c, stdex::extents< IndexType, Extents... > extents)
	Make an indexible object in which every diagonal element is a constant value. More...
template<typename C , typename P , std::enable_if_t< values::value< C > and coordinates::pattern_collection< P > and values::fixed< collections::size_of< P >>, int > = 0>
constexpr auto	make_constant_diagonal (C c, P &&p)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename C , typename... Ps, std::enable_if_t< values::value< C > and(... and coordinates::pattern< Ps >), int > = 0>
constexpr auto	make_constant_diagonal (C c, Ps &&...ps)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename C , typename P , std::enable_if_t< coordinates::pattern_collection< P > and values::value< C > and values::fixed< collections::size_of< P >>, int > = 0>
constexpr auto	make_constant_diagonal (C c)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename T , data_layout layout = data_layout::none, typename Scalar = scalar_type_of_t<T>, typename Descriptors , std::enable_if_t< indexible< T > and values::number< Scalar > and pattern_collection< D > and(layout !=data_layout::stride) and interface::make_default_defined_for< T, layout, Scalar, decltype(internal::to_euclidean_pattern_collection(std::declval< Descriptors &&>()))>, int > = 0>
constexpr auto	make_dense_object (Descriptors &&descriptors)
	Make a default, dense, writable matrix with a set of coordinates::pattern objects defining the dimensions. More...
template<typename T , data_layout layout = data_layout::none, typename Scalar = scalar_type_of_t<T>, typename... Ds, std::enable_if_t< indexible< T > and values::number< Scalar > and(... and coordinates::pattern< Ds >) and(layout !=data_layout::stride) and interface::make_default_defined_for< T, layout, Scalar, std::tuple< Ds &&... >>, int > = 0>
constexpr auto	make_dense_object (Ds &&...ds)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename T , typename layout = stdex::layout_right, typename Scalar = element_type_of_t<T>, typename... Ds, typename... Args, std::enable_if_t< indexible< T > and values::number< Scalar > and(coordinates::pattern< Ds > and ...) and(stdex::convertible_to< Args, const Scalar > and ...) and(stdex::same_as< layout, stdex::layout_right > or stdex::same_as< layout, stdex::layout_left >) and(((coordinates::dimension_of< Ds >::value==0) or ...) ? sizeof...(Args)==0 :(sizeof...(Args) %((dynamic_pattern< Ds > ? 1 :coordinates::dimension_of< Ds >::value) *... *1)==0)), int > = 0>
auto	make_dense_object_from (const std::tuple< Ds... > &d_tup, Args...args)
	Create a dense, writable matrix from the library of which dummy type T is a member, filled with a set of scalar components. More...
template<typename T , typename layout = std::compat::layout_right, typename Scalar = element_type_of_t<T>, typename ... Args>
auto	make_dense_object_from (Args...args)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , typename D0 , typename D1 >
constexpr auto	make_diagonal_adapter (Arg &&arg, D0 &&d0, D1 &&d1)
	Make a diagonal_matrix, specifying the first two dimensions, which may not necessarily be the same. More...
template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>
constexpr auto	make_diagonal_adapter (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<HermitianAdapterType adapter_type = HermitianAdapterType::lower, typename Arg , std::enable_if_t< square_shaped< Arg, applicability::permitted > and(adapter_type==HermitianAdapterType::lower or adapter_type==HermitianAdapterType::upper), int > = 0>
decltype(auto) constexpr	make_hermitian_matrix (Arg &&arg)
	Creates a hermitian_matrix by, if necessary, wrapping the argument in a hermitian_adapter. More...
template<typename T , typename Scalar = typename scalar_type_of<T>::type, typename Descriptors , std::enable_if_t< indexible< T > and values::number< Scalar > and pattern_collection< Descriptors >, int > = 0>
constexpr auto	make_identity_matrix_like (Descriptors &&descriptors)
	Make an identity_matrix with a particular set of coordinates::pattern objects. More...
template<typename T , typename Scalar = typename scalar_type_of<T>::type, typename... Ds, std::enable_if_t< indexible< T > and values::number< Scalar > and(... and coordinates::pattern< Ds >), int > = 0>
constexpr auto	make_identity_matrix_like (Ds &&...ds)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Scalar , typename Arg , std::enable_if_t< values::number< Scalar > and indexible< Arg >, int > = 0>
constexpr auto	make_identity_matrix_like (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>
constexpr auto	make_identity_matrix_like (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<triangle_type t = triangle_type::lower, typename Arg , std::enable_if_t< indexible< Arg > and(t==triangle_type::lower or t==triangle_type::upper or t==triangle_type::diagonal), int > = 0>
decltype(auto) constexpr	make_triangular_matrix (Arg &&arg)
	Create a triangular_matrix from a general matrix. More...
template<typename C = double, typename IndexType , std::size_t... Extents, std::enable_if_t< values::value< C >, int > = 0>
constexpr auto	make_zero (stdex::extents< IndexType, Extents... > extents)
	Make an indexible object in which every element is 0. More...
template<typename... Ds, typename Operation , typename... Args, std::enable_if_t<(coordinates::pattern< Ds > and ...) and(indexible< Args > and ...) and(sizeof...(Args) > 0>
constexpr auto	n_ary_operation (const std::tuple< Ds... > &d_tup, Operation &&operation, Args &&...args)
	Perform a component-wise n-ary operation, using broadcasting to match the size of a pattern matrix. More...
template<typename Operation , typename... Args, std::enable_if_t<(indexible< Args > and ...) and(sizeof...(Args) > 0>
constexpr auto	n_ary_operation (Operation &&operation, Args &&...args)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename PatternMatrix , std::size_t... indices, typename... Ds, typename... Operations>
constexpr auto	n_ary_operation (const std::tuple< Ds... > &d_tup, const Operations &...operations)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename PatternMatrix , std::size_t... indices, typename... Ds, typename... Operations, std::enable_if_t< indexible< PatternMatrix > and(coordinates::pattern< Ds > and ...) and((not dynamic_dimension< PatternMatrix, indices >) and ...) and(sizeof...(Operations)==(1 *... *index_dimension_of< PatternMatrix, indices >::value)), int > = 0>
constexpr auto	n_ary_operation (const Operations &...operations)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Operation , typename Arg , std::enable_if_t< writable< Arg > and detail::n_ary_operator< Operation, index_count_v< Arg >, Arg >, int > = 0>
decltype(auto) constexpr	unary_operation_in_place (const Operation &operation, Arg &&arg)
	Perform a component-wise, in-place unary operation. More...
template<typename A , std::enable_if_t< indexible< A >, int > = 0>
decltype(auto) constexpr	QR_decomposition (A &&a)
	Perform a QR decomposition of matrix A=Q[U,0], U is a upper-triangular matrix, and Q is orthogonal. More...
template<typename PatternMatrix , std::size_t... indices, typename random_number_generator , typename... Ds, typename... Dists>
constexpr auto	randomize (random_number_generator &gen, const std::tuple< Ds... > &ds_tuple, Dists &&...dists)
	Create an indexible object with random values selected from one or more random distributions. More...
template<typename PatternMatrix , std::size_t... indices, typename... Ds, typename... Dists>
constexpr auto	randomize (const std::tuple< Ds... > &d_tuple, Dists &&...dists)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename PatternMatrix , std::size_t... indices, typename random_number_generator , typename... Dists, std::enable_if_t< indexible< PatternMatrix > and(not has_dynamic_dimensions< PatternMatrix >) and(sizeof...(Dists)==(1 *... *index_dimension_of< PatternMatrix, indices >::value)) and((std::is_arithmetic_v< Dists > or detail::is_std_dist< Dists >::value) and ...), int > = 0>
constexpr auto	randomize (random_number_generator &gen, Dists &&...dists)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename PatternMatrix , std::size_t... indices, typename... Dists, std::enable_if_t< indexible< PatternMatrix > and(not has_dynamic_dimensions< PatternMatrix >) and(sizeof...(Dists)==(1 *... *index_dimension_of< PatternMatrix, indices >::value)) and((std::is_arithmetic_v< Dists > or detail::is_std_dist< Dists >::value) and ...), int > = 0>
constexpr auto	randomize (Dists &&...dists)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename A , typename U , std::enable_if_t< indexible< U > and hermitian_matrix< A, applicability::permitted > and dimension_size_of_index_is< U, 0, index_dimension_of< A, 0 >::value, applicability::permitted > and dimension_size_of_index_is< U, 0, index_dimension_of< A, 1 >::value, applicability::permitted > and stdex::convertible_to< typename scalar_type_of< U >::type, const typename scalar_type_of< A >::type >, int > = 0>
decltype(auto)	rank_update_hermitian (A &&a, U &&u, scalar_type_of_t< A > alpha=1)
	Do a rank update on a hermitian matrix. More...
template<typename A , typename U , std::enable_if_t< triangular_matrix< A, triangle_type::any > and indexible< U > and dimension_size_of_index_is< U, 0, index_dimension_of< A, 0 >::value, applicability::permitted > and dimension_size_of_index_is< U, 0, index_dimension_of< A, 1 >::value, applicability::permitted > and stdex::convertible_to< scalar_type_of_t< U >, const scalar_type_of_t< A >>, int > = 0>
decltype(auto)	rank_update_triangular (A &&a, U &&u, scalar_type_of_t< A > alpha=1)
	Do a rank update on triangular matrix. More...
template<std::size_t index, std::size_t... indices, typename BinaryFunction , typename Arg , std::enable_if_t< internal::has_uniform_patterns< Arg, index, indices... > and std::is_invocable_r< typename scalar_type_of< Arg >::type, BinaryFunction &&, typename scalar_type_of< Arg >::type, typename scalar_type_of< Arg >::type >::value, int > = 0>
decltype(auto) constexpr	reduce (BinaryFunction &&b, Arg &&arg)
	Perform a partial reduction based on an associative binary function, across one or more indices. More...
template<typename BinaryFunction , typename Arg , std::enable_if_t< internal::has_uniform_patterns< Arg > and std::is_invocable_r< typename scalar_type_of< Arg >::type, BinaryFunction &&, typename scalar_type_of< Arg >::type, typename scalar_type_of< Arg >::type >::value, int > = 0>
constexpr scalar_type_of_t< Arg >	reduce (const BinaryFunction &b, const Arg &arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<std::size_t... indices, typename Arg , typename Chip , typename... Ixs, std::enable_if_t< writable< Arg > and indexible< Chip > and(values::index< Ixs > and ...) and(sizeof...(indices)==sizeof...(Ixs)), int > = 0>
constexpr Arg &&	set_chip (Arg &&arg, Chip &&chip, Ixs...ixs)
	Set a sub-array having rank less than the rank of the input object. More...
template<typename Arg , typename Block , typename... Begin, std::enable_if_t< writable< Arg > and indexible< Block > and(values::index< Begin > and ...) and(sizeof...(Begin) > = index_count<Arg>::value>
constexpr Arg &&	set_slice (Arg &&arg, Block &&block, const Begin &...begin)
	Assign an object to a particular slice of a matrix or tensor. More...
template<bool must_be_unique = false, bool must_be_exact = false, typename A , typename B >
constexpr auto	solve (A &&a, B &&b)
	Solve the equation AX = B for X, which may or may not be a unique solution. More...
template<std::size_t... indices, typename Arg , typename... Ds, std::enable_if_t< indexible< Arg > and(coordinates::pattern< Ds > and ...) and(sizeof...(indices) > 0>
auto	split (Arg &&arg, Ds &&...ds)
	Split a matrix or tensor into sub-parts, where the split is the same for every index. More...
template<std::size_t... indices, typename Arg , typename... Ds_tups, std::enable_if_t< indexible< Arg > and(sizeof...(indices) > 0>
auto	split (Arg &&arg, const Ds_tups &...ds_tups)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename... Ts, std::enable_if_t<(indexible< Ts > and ...) and(sizeof...(Ts) > 0>
decltype(auto) constexpr	sum (Ts &&...ts)
	Element-by-element sum of one or more objects.
template<typename... Ds, typename Block , typename... Blocks, std::enable_if_t<(coordinates::pattern< Ds > and ...) and(indexible< Block > and ... and indexible< Blocks >) and(sizeof...(Ds) > = std::max({index_count<Block>::value, index_count<Blocks>::value...})>
decltype(auto) constexpr	tile (const std::tuple< Ds... > &ds_tuple, Block &&block, Blocks &&...blocks)
	Create a matrix or tensor by tiling individual blocks. More...
template<typename T , data_layout layout = data_layout::none, typename Scalar = scalar_type_of_t<T>, typename Arg , std::enable_if_t< indexible< T > and(layout !=data_layout::stride) and values::number< Scalar > and indexible< Arg >, int > = 0>
decltype(auto) constexpr	to_dense_object (Arg &&arg)
	Convert the argument to a dense, writable matrix of a particular scalar type. More...
template<data_layout layout, typename Scalar , typename Arg , std::enable_if_t< values::number< Scalar > and indexible< Arg > and(layout !=data_layout::stride), int > = 0>
decltype(auto) constexpr	to_dense_object (Arg &&arg)
	Convert the argument to a dense, writable matrix of a particular scalar type. More...
template<data_layout layout = data_layout::none, typename Arg , std::enable_if_t< indexible< Arg > and(layout !=data_layout::stride), int > = 0>
decltype(auto) constexpr	to_dense_object (Arg &&arg)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>
decltype(auto) constexpr	to_diagonal (Arg &&arg)
	Convert an indexible object into a diagonal matrix. More...
template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>
decltype(auto) constexpr	to_euclidean (Arg &&arg)
	Project the vector space associated with index 0 to a Euclidean space for applying directional statistics. More...
template<typename Arg >
decltype(auto) constexpr	trace (Arg &&arg)
	Take the trace of a matrix. More...
template<std::size_t indexa = 0, std::size_t indexb = 1, typename Arg >
decltype(auto) constexpr	transpose (Arg &&arg)
	Swap any two indices of an indexible_object. More...
template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>
decltype(auto) constexpr	wrap_angles (Arg &&arg)
template<typename RowCoefficients , typename ColumnCoefficients = RowCoefficients, typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>
auto	make_matrix (const Args...args)
template<typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>
auto	make_matrix (const Args ... args)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Scalar , typename RowCoefficients , typename ColumnCoefficients = RowCoefficients, std::enable_if_t< values::number< Scalar > and fixed_pattern< RowCoefficients > and fixed_pattern< ColumnCoefficients >, int > = 0>
auto	make_matrix ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename StaticDescriptor , typename ... Args, std::enable_if_t< fixed_pattern< StaticDescriptor > and(sizeof...(Args) > 0>
auto	make_mean (const Args ... args)
template<typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>
auto	make_mean (const Args ... args)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Scalar , typename StaticDescriptor , std::size_t cols = 1, std::enable_if_t< values::number< Scalar > and fixed_pattern< StaticDescriptor >, int > = 0>
auto	make_mean ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename StaticDescriptor , typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>
auto	make_euclidean_mean (const Args ... args)
template<typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>
auto	make_euclidean_mean (const Args ... args)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Scalar , typename StaticDescriptor , std::size_t cols = 1, std::enable_if_t< values::number< Scalar > and fixed_pattern< StaticDescriptor >, int > = 0>
auto	make_euclidean_mean ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename StaticDescriptor , triangle_type tri, typename ... Args, std::enable_if_t< fixed_pattern< StaticDescriptor > and(values::number< Args > and ...) and(tri==triangle_type::lower or tri==triangle_type::upper) and(sizeof...(Args) > 0>
auto	make_covariance (const Args ... args)
template<typename StaticDescriptor , typename ... Args, std::enable_if_t< fixed_pattern< StaticDescriptor > and(values::number< Args > and ...) and(sizeof...(Args) > 0>
auto	make_covariance (const Args ... args)
template<typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>
auto	make_covariance (const Args ... args)
template<typename StaticDescriptor , triangle_type tri = triangle_type::lower, typename ... Args, std::enable_if_t< fixed_pattern< StaticDescriptor > and(values::number< Args > and ...) and(tri==triangle_type::lower or tri==triangle_type::upper) and(sizeof...(Args) > 0>
auto	make_square_root_covariance (const Args ... args)
template<triangle_type tri = triangle_type::lower, typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>
auto	make_square_root_covariance (const Args ... args)
template<typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>
	Matrix (const Args ...) -> Matrix< Dimensions< sizeof...(Args)>, Axis, Eigen3::eigen_matrix_t< std::common_type_t< Args... >, sizeof...(Args), 1 >>
template<typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>
	Mean (const Args ...) -> Mean< Dimensions< sizeof...(Args)>, Eigen3::eigen_matrix_t< std::common_type_t< Args... >, sizeof...(Args), 1 >>
	If the arguments are a sequence of scalars, deduce a single-column mean with all Axis coefficients.
template<typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>
	EuclideanMean (const Args ...) -> EuclideanMean< OpenKalman::Dimensions< sizeof...(Args)>, Eigen3::eigen_matrix_t< std::common_type_t< Args... >, sizeof...(Args), 1 >>
	If the arguments are a sequence of scalars, construct a single-column Euclidean mean.
template<typename ... Args, std::enable_if_t<(values::number< Args > and ...) and(sizeof...(Args) > 0>
	Covariance (const Args &...) -> Covariance< Dimensions< static_cast< std::size_t >(values::sqrt(sizeof...(Args)))>, HermitianAdapter< Eigen3::eigen_matrix_t< std::common_type_t< Args... >, static_cast< std::size_t >(values::sqrt(sizeof...(Args))), static_cast< std::size_t >(values::sqrt(sizeof...(Args)))>>>
	If the arguments are a sequence of scalars, derive a square, self-adjoint matrix.
template<typename ... Args, std::enable_if_t<(values::number< Args > and ...) and(sizeof...(Args) > 0>
	SquareRootCovariance (const Args &...) -> SquareRootCovariance< Dimensions< static_cast< std::size_t >(values::sqrt(sizeof...(Args)))>, TriangularAdapter< Eigen3::eigen_matrix_t< std::common_type_t< Args... >, static_cast< std::size_t >(values::sqrt(sizeof...(Args))), static_cast< std::size_t >(values::sqrt(sizeof...(Args)))>>>
	If the arguments are a sequence of scalars, derive a square, lower triangular matrix.
template<typename Arg , typename Indices , std::enable_if_t< index_collection_for< Indices, Arg > and(not empty_object< Arg >) and(not values::size_compares_with< collections::size_of< Indices >, index_count< Arg >, &stdex::is_lt >), int > = 0>
decltype(auto) constexpr	access (Arg &&arg, const Indices &indices)
	Access a component of an indexible object at a given set of indices. More...
template<typename Arg , typename... I, std::enable_if_t< indexible< Arg > and(... and values::index< I >) and(not empty_object< Arg >) and(not values::size_compares_with< std::integral_constant< std::size_t, sizeof...(I)>, index_count< Arg >, &stdex::is_lt >), int > = 0>
decltype(auto) constexpr	access (Arg &&arg, I...i)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Arg , typename Indices , std::enable_if_t< index_collection_for< Indices, Arg > and(not empty_object< Arg >) and(not values::size_compares_with< collections::size_of< Indices >, index_count< Arg >, &stdex::is_lt >), int > = 0>
decltype(auto) constexpr	access_at (Arg &&arg, const Indices &indices)
	Access a component of an indexible object at a given set of indices, with bounds checking. More...
template<typename Arg , typename... I, std::enable_if_t< indexible< Arg > and(... and values::index< I >) and(not empty_object< Arg >) and(not values::size_compares_with< std::integral_constant< std::size_t, sizeof...(I)>, index_count< Arg >, &stdex::is_lt >), int > = 0>
decltype(auto) constexpr	access_at (Arg &&arg, I...i)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename T , std::enable_if_t< constant_object< T > or constant_diagonal_object< T >, int > = 0>
constexpr auto	constant_value (T &&t)
	The constant value associated with a constant_object or constant_diagonal_object.
template<typename T , std::enable_if_t< indexible< T >, int > = 0>
constexpr auto	count_indices (const T &)
	Get the number of indices necessary to address all the components of an indexible object. More...
template<typename T , typename I = std::integral_constant<std::size_t, 0>, std::enable_if_t< indexible< T > and values::index< I >, int > = 0>
constexpr auto	get_index_extent (T &&t, I i=I{})
	Get the runtime dimensions of index N of indexible T.
template<std::size_t I, typename T , std::enable_if_t< indexible< T >, int > = 0>
constexpr auto	get_index_extent (T &&t)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename T , typename I = std::integral_constant<std::size_t, 0>, std::enable_if_t< indexible< T > and values::index< I >, int > = 0>
decltype(auto) constexpr	get_index_pattern (T &&t, I i={})
	Get the coordinates::pattern associated with indexible object T at a given index. More...
template<std::size_t i, typename T , std::enable_if_t< indexible< T >, int > = 0>
constexpr auto	get_index_pattern (T &&t)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename T , std::enable_if_t< indexible< T >, int > = 0>
constexpr auto	get_mdspan (T &t)
	Get the coordinates::pattern_collection associated with indexible object T.
template<typename T , typename Extents , typename LayoutPolicy , typename AccessorPolicy >
constexpr auto	get_mdspan (stdex::mdspan< T, Extents, LayoutPolicy, AccessorPolicy > m)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename T , std::enable_if_t< indexible< T >, int > = 0>
decltype(auto) constexpr	get_pattern_collection (T &&t)
	Get the coordinates::pattern_collection associated with indexible object T.
template<typename T , std::enable_if_t< interface::count_indices_defined_for< T >, int > = 0>
constexpr bool	get_wrappable (const T &t)
	Determine whether T is wrappable (i.e., all its dimensions other than potentially 0 are euclidean). More...
template<typename T , std::enable_if_t< indexible< T >, int > = 0>
constexpr auto	is_one_dimensional (const T &t)
	Determine whether T is one_dimensional, meaning that every index has a dimension of 1. More...
template<typename T , std::enable_if_t< indexible< T >, int > = 0>
constexpr auto	is_square_shaped (const T &t)
	Determine whether an object is square_shaped. More...
template<std::size_t N = 0, typename T , std::enable_if_t< indexible< T >, int > = 0>
constexpr auto	is_vector (const T &t)
	Return true if T is a vector at runtime. More...
template<typename Arg , std::enable_if_t< has_nested_object< Arg >, int > = 0>
decltype(auto) constexpr	nested_object (Arg &&arg)
	Retrieve a nested object of Arg, if it exists. More...
template<typename... Ts, std::enable_if_t<(indexible< Ts > and ...), int > = 0>
constexpr bool	patterns_match (const Ts &...ts)
	Return true if every set of coordinates::pattern of a set of objects are equivalent. More...
template<typename T , std::enable_if_t< indexible< T >, int > = 0>
constexpr auto	tensor_order (const T &t)
	Return the tensor order of T (i.e., the number of indices of dimension greater than 1). More...
template<typename OutputCoefficients , typename In , typename ... Perturbations>
auto	zero_hessian ()
	A tuple of zero-filled arrays of Hessian matrices, based on the input and each perturbation term.
template<typename OutputCoefficients , typename In , typename ... Perturbations>
auto	zero_hessian (In &&, Perturbations &&...)
	A tuple of zero-filled arrays of Hessian matrices, based on the input and each perturbation term.
template<typename Function , typename InDelta , typename ... PsDelta>
	FiniteDifferenceLinearization (Function &&, InDelta &&, PsDelta &&...) -> FiniteDifferenceLinearization< std::decay_t< Function >, std::decay_t< InDelta >, std::decay_t< PsDelta >... >
template<typename T , typename ... Ps>
	LinearTransformation (T &&, Ps &&...) -> LinearTransformation< vector_space_descriptor_of_t< T, 1 >, vector_space_descriptor_of_t< T, 0 >, equivalent_self_contained_t< nested_object_of_t< T >>, equivalent_self_contained_t< std::conditional_t< typed_matrix< Ps >, nested_object_of_t< Ps >, Ps >>... >
template<typename Function , typename ... TaylorDerivatives>
	Transformation (Function &&, TaylorDerivatives &&...) -> Transformation< std::decay_t< Function >, std::decay_t< TaylorDerivatives > ... >
template<typename Function , std::enable_if_t< linearized_function< Function, 0 > and(not linearized_function< Function, 1 >), int > = 0>
	Transformation (Function &&) -> Transformation< std::decay_t< Function >>
constexpr applicability	operator not (applicability x)
constexpr applicability	operator and (applicability x, applicability y)
constexpr applicability	operator or (applicability x, applicability y)

Variables
template<typename T >
constexpr bool	from_euclidean_expr = detail::is_from_euclidean_expr<std::decay_t<T>>::value
	Specifies that T is an expression converting coefficients from Euclidean space (i.e., FromEuclideanExpr).
template<typename T >
constexpr bool	to_euclidean_expr = detail::is_to_euclidean_expr<std::decay_t<T>>::value
	Specifies that T is an expression converting coefficients to Euclidean space (i.e., ToEuclideanExpr).
template<typename T >
constexpr bool	euclidean_expr = from_euclidean_expr<T> or to_euclidean_expr<T>
	Specifies that T is either to_euclidean_expr or from_euclidean_expr.
template<typename T >
constexpr bool	all_fixed_indices_are_euclidean
	Specifies that every fixed-size index of T is euclidean. More...
template<typename T , typename D , auto comp = &stdex::is_eq, applicability a = applicability::permitted>
constexpr bool	compares_with_pattern_collection
	Compares the associated pattern collection of indexible T with pattern_collection D. More...
template<typename T >
constexpr bool	constant_diagonal_object
	Specifies that all diagonal elements of a diagonal object are known at compile time to be the same constant value. More...
template<typename T >
constexpr bool	constant_object
	Specifies that all elements of an object are known at compile time to be the same constant value. More...
template<typename Dest , typename Source >
constexpr bool	copyable_from
	Specifies that an indexible object is copyable from another indexible object. More...
template<typename T >
constexpr bool	diagonal_matrix
	Specifies that a type is a diagonal matrix or tensor. More...
template<typename T , std::size_t index, std::size_t value, auto comp = &stdex::is_eq, applicability b = applicability::guaranteed>
constexpr bool	dimension_size_of_index_is
	Specifies that a given index of T has a specified size. More...
template<typename T , std::size_t N>
constexpr bool	dynamic_dimension = detail::is_dynamic_dimension<T, N>::value
	Specifies that T's index N has a dimension defined at run time. More...
template<typename T >
constexpr bool	empty_object = detail::empty_object_impl<T>()
	Specifies that an object is empty (i.e., at least one index is zero-dimensional).
template<typename T >
constexpr bool	has_dynamic_dimensions
	Specifies that T has at least one index with dynamic dimensions. More...
template<typename T >
constexpr bool	has_nested_object
	A matrix that has a nested matrix, if it is a wrapper type. More...
template<typename T , std::size_t N>
constexpr bool	has_untyped_index
	Specifies that T has an untyped index N. More...
template<typename T , HermitianAdapterType t = HermitianAdapterType::any>
constexpr bool	hermitian_adapter = hermitian_matrix<T> and detail::hermitian_adapter_impl<std::decay_t<T>, t>::value
	Specifies that a type is a hermitian matrix adapter of a particular type. More...
template<typename T >
constexpr bool	hermitian_matrix
	Specifies that a type is a hermitian matrix. More...
template<typename T >
constexpr bool	identity_matrix
	Specifies that a type is known at compile time to be a rank-2 or lower identity matrix. More...
template<typename Indices , typename T >
constexpr bool	index_collection_for
	Indices is a collection of indices that are compatible with indexible object T. More...
template<typename T >
constexpr bool	indexible
	T is a multidimensional array type. More...
template<typename T >
constexpr bool	mean = internal::is_mean<std::decay_t<T>>::value
	Specifies that T is a mean (i.e., is a specialization of the class Mean).
template<typename T >
constexpr bool	wrapped_mean
	Specifies that T is a wrapped mean (i.e., its row fixed_pattern have at least one type that requires wrapping). More...
template<typename T >
constexpr bool	euclidean_mean = internal::is_euclidean_mean<std::decay_t<T>>::value
	Specifies that T is a Euclidean mean (i.e., is a specialization of the class EuclideanMean).
template<typename T >
constexpr bool	euclidean_transformed
	Specifies that T is a Euclidean mean that actually has coefficients that are transformed to Euclidean space. More...
template<typename T >
constexpr bool	typed_matrix = mean<T> or euclidean_mean<T> or internal::is_matrix<std::decay_t<T>>::value
	Specifies that T is a typed matrix (i.e., is a specialization of Matrix, Mean, or EuclideanMean).
template<typename T >
constexpr bool	self_adjoint_covariance = internal::is_self_adjoint_covariance<std::decay_t<T>>::value
	T is a self-adjoint covariance matrix (i.e., a specialization of Covariance).
template<typename T >
constexpr bool	triangular_covariance = internal::is_triangular_covariance<std::decay_t<T>>::value
	T is a square root (Cholesky) covariance matrix (i.e., a specialization of SquareRootCovariance).
template<typename T >
constexpr bool	covariance = self_adjoint_covariance<T> or triangular_covariance<T>
	T is a specialization of either Covariance or SquareRootCovariance.
template<typename T >
constexpr bool	gaussian_distribution = internal::is_gaussian_distribution<std::decay_t<T>>::value
	T is a Gaussian distribution.
template<typename T >
constexpr bool	distribution = gaussian_distribution<T>
	T is a statistical distribution of any kind that is defined in OpenKalman.
template<typename T >
constexpr bool	cholesky_form = detail::is_cholesky_form<std::decay_t<T>>::value
	Specifies that a type has a nested native matrix that is a Cholesky square root. More...
template<typename T >
constexpr bool	covariance_nestable
	T is an acceptable nested matrix for a covariance (including triangular_covariance). More...
template<typename T >
constexpr bool	typed_matrix_nestable
	Specifies a type that is nestable in a general typed matrix (e.g., matrix, mean, or euclidean_mean) More...
template<typename T , applicability b = applicability::guaranteed>
constexpr bool	one_dimensional
	Specifies that a type is one-dimensional in every index. More...
template<typename P , typename T , applicability a = applicability::permitted>
constexpr bool	pattern_collection_for = detail::compatible_shape_with_impl_cpp17<P, T, a>::value
	pattern collection P is compatible with indexible T. More...
template<typename... Ts>
constexpr bool	patterns_match_with
	Specifies that a set of indexible objects have equivalent vector space descriptors for each index. More...
template<typename... Ts>
constexpr bool	patterns_may_match_with
	Specifies that indexible objects Ts may have equivalent dimensions and vector-space types. More...
template<typename T , applicability b = applicability::guaranteed>
constexpr bool	square_shaped
	Specifies that an object is square (i.e., has equivalent coordinates::pattern along each dimension). More...
template<typename T >
constexpr bool	triangular_adapter
	Specifies that a type is a triangular adapter of triangle type tri. More...
template<typename T , triangle_type t = triangle_type::any>
constexpr bool	triangular_matrix
	Specifies that an argument is an indexible object having a given triangle_type (e.g., upper, lower, or diagonal). More...
template<typename T >
constexpr bool	typed_adapter
	Specifies that T is a typed adapter expression. More...
template<typename T >
constexpr bool	untyped_adapter
	Specifies that T is an untyped adapter expression. More...
template<typename T , std::size_t N = 0, applicability b = applicability::guaranteed>
constexpr bool	vector
	T is a vector (e.g., column or row vector). More...
template<typename T >
constexpr bool	wrappable = detail::is_wrappable<T>::value
	Specifies that every fixed-size index of T (other than potentially index 0) is euclidean. More...
template<typename T , unsigned int epsilon_factor = 0>
constexpr bool	zero
	Specifies that a type is known at compile time to be a constant matrix of value zero. More...
template<typename T >
constexpr auto	constant_value_of_v = constant_value_of<T>::value
	helper template for constant_value_of.
template<typename T , typename... Ts>
constexpr auto	hermitian_adapter_type_of_v = hermitian_adapter_type_of<T, Ts...>::value
	The triangle_type associated with the storage triangle of a hermitian_matrix. More...
template<typename T >
constexpr auto	triangle_type_of_v = triangle_type_of<T>::value
	Helper template for triangle_type_of.
template<typename T , std::size_t order = 1>
constexpr bool	linearized_function
	A linearized function (with defined Jacobian and optionally Hessian functions). More...
template<typename T , typename Coeffs = typename oin::PerturbationTraits<T>::RowCoefficients>
constexpr bool	transformation_input
	T is an acceptable input to a tests. More...
template<typename T , typename Coeffs = typename oin::PerturbationTraits<T>::RowCoefficients>
constexpr bool	perturbation = OpenKalman::detail::is_perturbation<T, Coeffs>::value

Detailed Description

The root namespace for OpenKalman.

The namespace for all OpenKalman-specific classes and methods.

Typedef Documentation

dense_writable_matrix_t

template<typename T , data_layout layout = data_layout::none, typename S = scalar_type_of_t<T>, typename D = decltype(all_vector_space_descriptors(std::declval<T>())), std::enable_if_t< indexible< T > and values::number< S > and pattern_collection< D >, int > = 0>

using OpenKalman::dense_writable_matrix_t = typedef std::decay_t<decltype(make_dense_object<T, layout, S>(std::declval<D>()))>

An alias for a dense, writable matrix, patterned on parameter T.

Template Parameters

T	A matrix or array from the relevant matrix library.
S	A scalar type (may or may not be scalar_type_of_t<T>.
layout	The /ref data_layout of the result.
D	A pattern_collection defining the new object. This will be derived from T if omitted.

nested_object_of_t

template<typename T >

using OpenKalman::nested_object_of_t = typedef typename nested_object_of<T>::type

Helper type for nested_object_of.

Template Parameters

T	A wrapper type that has a nested matrix.

zero_adapter

template<typename Shape , typename N = element_type_of_t<Shape>>

using OpenKalman::zero_adapter = typedef constant_adapter<values::fixed_value<N, 0>, Shape>

A constant_adapter in which all elements are 0.

Template Parameters

Shape	An indexible object reflecting the size and shape of the adapter object.
N	A values::number type (by default, derived from Shape).

Enumeration Type Documentation

applicability

enum OpenKalman::applicability : int

strong

The applicability of a concept, trait, or restraint.

Determines whether something is necessarily applicable, or alternatively just permissible, at compile time. Examples:

• square_shaped<T, applicability::guaranteed> means that T is known at compile time to be square shaped.
• square_shaped<T, applicability::permitted> means that T could be square shaped, but whether it actually is cannot be determined at compile time.

Enumerator
guaranteed	The concept, trait, or restraint represents a compile-time guarantee.
permitted	The concept, trait, or restraint is permitted, but whether it applies is not necessarily known at compile time.

HermitianAdapterType

enum OpenKalman::HermitianAdapterType : int

strong

The type of a hermitian adapter, indicating which triangle of the nested matrix is used.

This type can be statically cast from triangle_type so that lower, upper, and any correspond to each other. The value none corresponds to triangle_type::diagonal.

Enumerator
none	Not a hermitian adapter.
any	Either lower or upper hermitian adapter.
lower	A lower-left hermitian adapter.
upper	An upper-right hermitian adapter.

triangle_type

enum OpenKalman::triangle_type : int

strong

The type of a triangular matrix.

This is generally applicable to a rank-2 tensor (e.g., a matrix). It also applies to tensors of rank > 2, in which case every rank-2 slice over dimensions 0 and 1 must be a triangle of this type.

Enumerator
none	Not triangular.
any	Lower, upper, or diagonal matrix.
lower	A lower-left triangular matrix.
upper	An upper-right triangular matrix.
diagonal	A diagonal matrix (both a lower-left and an upper-right triangular matrix).

Function Documentation

access() [1/2]

template<typename Arg , typename Indices , std::enable_if_t< index_collection_for< Indices, Arg > and(not empty_object< Arg >) and(not values::size_compares_with< collections::size_of< Indices >, index_count< Arg >, &stdex::is_lt >), int > = 0>

decltype(auto) constexpr OpenKalman::access	(	Arg &&	arg,
		const Indices &	indices
	)

Access a component of an indexible object at a given set of indices.

This performs no bounds checking

Template Parameters

Arg	The indexible object to be accessed.
Indices	A sized input range containing the indices.

Returns

a reference to a values::value

access() [2/2]

template<typename Arg , typename... I, std::enable_if_t< indexible< Arg > and(... and values::index< I >) and(not empty_object< Arg >) and(not values::size_compares_with< std::integral_constant< std::size_t, sizeof...(I)>, index_count< Arg >, &stdex::is_lt >), int > = 0>

decltype(auto) constexpr OpenKalman::access	(	Arg &&	arg,
		I...	i
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Access a component based on a pack of indices.

access_at() [1/2]

template<typename Arg , typename Indices , std::enable_if_t< index_collection_for< Indices, Arg > and(not empty_object< Arg >) and(not values::size_compares_with< collections::size_of< Indices >, index_count< Arg >, &stdex::is_lt >), int > = 0>

decltype(auto) constexpr OpenKalman::access_at	(	Arg &&	arg,
		const Indices &	indices
	)

Access a component of an indexible object at a given set of indices, with bounds checking.

This is the same as access, except with added bounds checking

Template Parameters

Arg	The object to be accessed.
Indices	A sized input range containing the indices.

Returns

a values::scalar (value or reference)

See also

access

access_at() [2/2]

template<typename Arg , typename... I, std::enable_if_t< indexible< Arg > and(... and values::index< I >) and(not empty_object< Arg >) and(not values::size_compares_with< std::integral_constant< std::size_t, sizeof...(I)>, index_count< Arg >, &stdex::is_lt >), int > = 0>

decltype(auto) constexpr OpenKalman::access_at	(	Arg &&	arg,
		I...	i
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Access a component based on a pack of indices.

adjoint()

template<std::size_t indexa = 0, std::size_t indexb = 1, typename Arg >

decltype(auto) constexpr OpenKalman::adjoint

(

Arg &&

arg

)

Take the conjugate-transpose of an indexible_object.

By default, the first two indices are transposed.

attach_pattern() [1/3]

template<typename Arg , typename P , std::enable_if_t< indexible< Arg > and pattern_collection_for< P, Arg >, int > = 0>

constexpr auto OpenKalman::attach_pattern	(	Arg &&	arg,
		P &&	p
	)

Attach a pattern_collection to an indexible object.

Any pattern_collection already associated with the argument will be overwritten.

attach_pattern() [2/3]

template<typename Arg , typename... Ps, std::enable_if_t< indexible< Arg > and(... and coordinates::pattern< Ps >) and pattern_collection_for< std::tuple< Ps... >, Arg >, int > = 0>

constexpr auto OpenKalman::attach_pattern	(	Arg &&	arg,
		Ps &&...	ps
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

The pattern_collection is constructed from a list of coordinates::pattern objects.

attach_pattern() [3/3]

template<typename P , typename Arg , std::enable_if_t< indexible< Arg > and pattern_collection_for< P, Arg >, int > = 0>

constexpr auto OpenKalman::attach_pattern

(

Arg &&

arg

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

The pattern_collection is default initializable.

average_reduce() [1/2]

template<std::size_t index, std::size_t... indices, typename Arg , std::enable_if_t< internal::has_uniform_patterns< Arg, index, indices... > and(not empty_object< Arg >), int > = 0>

decltype(auto) constexpr OpenKalman::average_reduce

(

Arg &&

arg

)

Perform a partial reduction by taking the average along one or more indices.

Template Parameters

index	an index to be reduced. For example, if the index is 0, the result will have only one row. If the index is 1, the result will have only one column.
indices	Other indices to be reduced. Because the binary function is associative, the order of the indices does not matter.

Returns

A vector or tensor with reduced dimensions.

average_reduce() [2/2]

template<typename Arg , std::enable_if_t< internal::has_uniform_patterns< Arg >, int > = 0>

constexpr scalar_type_of_t<Arg> OpenKalman::average_reduce

(

Arg &&

arg

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Perform a complete reduction by taking the average along all indices and returning a scalar value.

Returns

A scalar representing the average of all components.

broadcast()

template<typename Arg , typename... Factors, std::enable_if_t< indexible< Arg > and(... and values::index< Factors >), int > = 0>

decltype(auto) constexpr OpenKalman::broadcast	(	Arg &&	arg,
		const Factors &...	factors
	)

Broadcast an object by replicating it by factors specified for each index.

The operation may increase the order of the object by specifying factors greater than 1 for higher indices. Any such higher indices will have a coordinates::pattern of Dimensions<n> where n is the factor.

Template Parameters

Arg	The object.
Factors	A set of factors, each an values::index, indicating the increase in size of each index. Any omitted trailing factors are treated as factor 1 (no broadcasting along that index).

chipwise_operation() [1/2]

template<std::size_t... indices, typename Operation , typename... Args, std::enable_if_t<(indexible< Args > and ...) and(sizeof...(Args) > 0>

constexpr auto OpenKalman::chipwise_operation	(	const Operation &	operation,
		Args &&...	args
	)

Perform a chipwise n-ary operation (n>0) on one or more indexible objects.

Given an indexible object of order k, a "chip" is a subset of that object, having order in the range (0, k]. This function takes same-size chips from each of the arguments and performs an operation returning a chip (of the same size), for every possible chip within the result.

Template Parameters

indices	The one-dimensional indices of the chip (optionally excluding any trailing 1D indices). If omitted, the order of the chip is the same as that of the highest-order indexible argument. Note: the list of indices must be non-repeating, or a compile-time assertion will fail.
Operation	An n-ary operation (unary, binary, etc.) on n chips of the same size. In addition to taking one or more chips as arguments, the operation may optionally take sizeof...(indices) indices (in the same order as indices).
Args	The arguments, which must be the same size.

Returns

An object of the same size as the highest-order argument. For example, a chipwise operation between a 3×4 matrix and either a 3×1 row or 1×4 column vector is a 3×4 matrix. (The vector is replicated vertically or horizontally, respectively, to fill the size of the matrix.)

chipwise_operation() [2/2]

template<std::size_t... indices, typename Operation , typename... Is, std::enable_if_t<(values::index< Is > and ...) and(sizeof...(Is)==sizeof...(indices)), int > = 0>

constexpr auto OpenKalman::chipwise_operation	(	const Operation &	operation,
		Is...	is
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Perform a chipwise nullary operation.

The nullary operation returns a chip, and that chip is replicated along the specified indices a number of times indicated by Is.

Template Parameters

Operation	A nullary operation. The operation may optionally take, as arguments, sizeof...(indices) indices (in the same order as indices).
Is	Number of dimensions corresponding to each of indices....

cholesky_factor() [1/2]

template<triangle_type tri, typename A , std::enable_if_t< hermitian_matrix< A, applicability::permitted > and(tri !=triangle_type::diagonal or diagonal_matrix< A >), int > = 0>

decltype(auto) constexpr OpenKalman::cholesky_factor

(

A &&

a

)

Take the Cholesky factor of a matrix.

Template Parameters

A	A hermitian matrix.
tri	Either triangle_type::upper, triangle_type::lower, or triangle_type::diagonal (only if A is a diagonal_matrix).

Returns

T, where the argument is in the form A = TT^T.

cholesky_factor() [2/2]

template<typename A , std::enable_if_t< hermitian_matrix< A, applicability::permitted >, int > = 0>

decltype(auto) constexpr OpenKalman::cholesky_factor

(

A &&

a

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

This overload does not require specifying the triangle_type, which is either

triangle_type::diagonal if A is diagonal;

the hermitian adapter triangle type of A, if it exists; or

triangle_type::lower, by default.

cholesky_square()

template<typename A , std::enable_if_t< triangular_matrix< A > and square_shaped< A, applicability::permitted >, int > = 0>

decltype(auto) constexpr OpenKalman::cholesky_square

(

A &&

a

)

Take the Cholesky square of a triangular_matrix.

Template Parameters

A	A square matrix.

Returns

AA^* (if A is lower triangular_matrix) or otherwise A^*A.

concatenate()

template<std::size_t... indices, typename Arg , typename... Args, std::enable_if_t<(sizeof...(indices) > 0>

decltype(auto) constexpr OpenKalman::concatenate	(	Arg &&	arg,
		Args &&...	args
	)

Concatenate some number of objects along one or more indices.

Template Parameters

indices	The indices along which the concatenation occurs. For example, if indices is {0}, concatenation is along row index 0, and is a vertical concatenation; if indices is {1}, concatenation is along column index 1, and is a horizontal concatenation; and if indices is {0, 1} or {1, 0}, concatenation is diagonal along both row and column directions.
Arg	First object to be concatenated
Args	Other objects to be concatenated

Returns

The concatenated object

Todo:

Deal with case where there are a dynamic number of indices

conjugate()

template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>

decltype(auto) constexpr OpenKalman::conjugate

(

Arg &&

arg

)

Take the complex conjugate of an indexible object.

The resulting object has every element substituted with its complex conjugate.

contract_in_place()

template<bool on_the_right = true, typename A , typename B >

constexpr A&& OpenKalman::contract_in_place	(	A &&	a,
		B &&	b
	)

In-place matrix multiplication of A * B, storing the result in A.

Template Parameters

on_the_right

Whether the application is on the right (true) or on the left (false)

Returns

Either A * B (if on_the_right == true) or B * A (if on_the_right == false)

copy_from()

template<typename Source , typename Dest , std::enable_if_t< copyable_from< Dest, Source >, int > = 0>

decltype(auto) constexpr OpenKalman::copy_from	(	Dest &&	dest,
		Source &&	source
	)

Copy elements from one object to another.

Parameters

dest	The destination object.
source	The source object.

Returns

A reference to the destination object as modified

By default, this simply loops through each element of the associated mdspans.

count_indices()

template<typename T , std::enable_if_t< indexible< T >, int > = 0>

constexpr auto OpenKalman::count_indices

(

const T &

)

Get the number of indices necessary to address all the components of an indexible object.

See also

index_count

Covariance()

template<typename M , std::enable_if_t< covariance_nestable< M >, int > = 0>

OpenKalman::Covariance ( M &&  ) -> Covariance< Dimensions< index_dimension_of_v< M, 0 >>, passable_t< M >>

explicit

Deduce Covariance type from a covariance_nestable.

Deduce Covariance type from a square typed_matrix_nestable.

Deduce Covariance type from a square typed_matrix.

determinant()

template<typename Arg >

constexpr auto OpenKalman::determinant

(

Arg &&

arg

)

Take the determinant of a matrix.

Template Parameters

Arg	A square matrix

diagonal_of()

template<typename Arg >

decltype(auto) constexpr OpenKalman::diagonal_of

(

Arg &&

arg

)

Extract a column vector (or column slice for rank>2 tensors) comprising the diagonal elements.

Template Parameters

Arg	An indexible object, which can have any rank and may or may not be square

Returns

Arg A column vector whose coordinates::pattern corresponds to the smallest-dimension index.

Todo:

generalize for higher-rank tensors

EuclideanMean()

template<typename V , std::enable_if_t< typed_matrix< V > and not euclidean_transformed< V > and has_untyped_index< V, 1 > andcoordinates::stat_dimension_of_v< vector_space_descriptor_of_t< V, 0 >>==index_dimension_of_v< V, 0 >, int > = 0>

OpenKalman::EuclideanMean ( V &&  ) -> EuclideanMean< vector_space_descriptor_of_t< V, 0 >, std::remove_reference_t< decltype(to_euclidean< vector_space_descriptor_of_t< V, 0 >>(nested_object(std::declval< V &&>())))>>

explicit

Deduce template parameters from a non-Euclidean-transformed typed matrix.

Deduce template parameters from a typed_matrix_nestable, assuming axis-only coefficients.

Deduce template parameters from a Euclidean-transformed typed matrix.

fill_components()

template<typename layout layout = stdex::layout_right, typename Arg , typename... S, std::enable_if_t< indexible< Arg > and(values::number< S > and ...) and(std::same_as< layout, stdex::layout_right > or std::same_as< layout, stdex::layout_left >) and internal::may_hold_components< Arg, S... > and(sizeof...(S)==0 or interface::fill_components_defined_for< Arg, layout, std::add_lvalue_reference_t< Arg >, S... >), int > = 0>

Arg&& OpenKalman::fill_components ( Arg &&  arg, S...  s  )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Fill the components of an object from a list of scalar values.

The scalar components are listed in the specified layout order, as follows:

• std::layout_left: column-major;
• std::layout_right: row-major (the default).

  Template Parameters

  layout

  The layout_mapping_policy of Args and the resulting object (std::layout_right if unspecified).

  Parameters

  arg	The object to be modified.
  s	Scalar values to fill the new matrix.

from_euclidean()

template<typename Arg , typename V , std::enable_if_t< coordinates::euclidean_pattern< vector_space_descriptor_of_t< Arg, 0 >> and coordinates::pattern< V >, int > = 0>

decltype(auto) constexpr OpenKalman::from_euclidean	(	Arg &&	arg,
		const V &	v
	)

Project the Euclidean vector space associated with index 0 to coordinates::pattern v after applying directional statistics.

Template Parameters

Arg	A matrix or tensor.
V	The new coordinate_list of index 0.

get_chip()

template<std::size_t... indices, typename Arg , typename... Ixs, std::enable_if_t< indexible< Arg > and(values::index< Ixs > and ...) and(sizeof...(indices)==sizeof...(Ixs)), int > = 0>

decltype(auto) constexpr OpenKalman::get_chip	(	Arg &&	arg,
		Ixs...	ixs
	)

Extract a sub-array having rank less than the rank of the input object.

A chip is a special type of "thin" slice of width 1 in one or more dimensions, and otherwise no reduction in extents. For example, the result could be a row vector, a column vector, a matrix (e.g., if the input object is a rank-3 or higher tensor), etc.

Template Parameters

indices

The index or indices of the dimension(s) to be collapsed to a single dimension. For example, if the input object is a matrix, a value of {0} will result in a row vector, a value of {1} will result in a column vector, and a value of {0, 1} will result in a one-dimensional vector. If the input object is a rank-3 tensor, a value of {1, 2} will result in a row vector. If no indices are listed, the argument will be returned unchanged.

Parameters

ixs	The index value corresponding to each of the indices, in the same order. The values may be positive std::integral types or a positive std::integral_constant.

Returns

A sub-array of the argument

get_index_pattern()

template<typename T , typename I = std::integral_constant<std::size_t, 0>, std::enable_if_t< indexible< T > and values::index< I >, int > = 0>

decltype(auto) constexpr OpenKalman::get_index_pattern	(	T &&	t,
		I	i = {}
	)

Get the coordinates::pattern associated with indexible object T at a given index.

If the index exceeds count_indices(t), the result is coordinates::Dimensions<1>{}, coordinates::Any{1UZ}, or 1UZ.

get_mdspan()

template<typename T , typename Extents , typename LayoutPolicy , typename AccessorPolicy >

constexpr auto OpenKalman::get_mdspan

(

stdex::mdspan< T, Extents, LayoutPolicy, AccessorPolicy >

m

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

If argument is already an mdspan, return it unchanged.

get_slice()

template<std::size_t... indices, typename Arg , typename... Offset, typename... Extent, std::enable_if_t< indexible< Arg > and(values::index< Offset > and ...) and(values::index< Extent > and ...) and(sizeof...(Offset)==sizeof...(Extent)) and internal::has_uniform_patterns< Arg, indices... > and(sizeof...(indices)==0 or sizeof...(indices)==sizeof...(Offset)), int > = 0>

decltype(auto) constexpr OpenKalman::get_slice	(	Arg &&	arg,
		const std::tuple< Offset... > &	offsets,
		const std::tuple< Extent... > &	extents
	)

Extract a slice from a matrix or tensor.

If indices are specified, only those indices will be subsetted. Otherwise, the Offset and Extent parameters are taken in index order. Any omitting trailing indices (for which there are no Offset or Extent parameters) are included whole.

Template Parameters

indices

The index or indices of the particular dimensions to be specified, in any order (optional). If this is omitted, the Offset and Extent parameters proceed in index order.

Parameters

arg	The indexible object from which a slice is to be taken.
offsets	A tuple corresponding to each of indices, each element specifying the offsetning values::index. If indices are not specified, the tuple proceeds in normal index order.
extents	A tuple corresponding to each of indices, each element specifying the dimensions of the extracted block. If indices are not specified, the tuple proceeds in normal index order.

get_wrappable()

template<typename T , std::enable_if_t< interface::count_indices_defined_for< T >, int > = 0>

constexpr bool OpenKalman::get_wrappable

(

const T &

t

)

Determine whether T is wrappable (i.e., all its dimensions other than potentially 0 are euclidean).

Template Parameters

T	A matrix or array

Todo:

Is this necessary?

See also

wrappable

inverse_scale()

template<typename M , typename S , std::enable_if_t< covariance< M > and stdex::convertible_to< S, typename scalar_type_of< M >::type >, int > = 0>

auto OpenKalman::inverse_scale ( M &&  m, const S  s  )

inline

Scale a covariance by the inverse of a scalar factor.

Equivalent by division by the square of a scalar. For a square root covariance, this is equivalent to division by the scalar.

is_one_dimensional()

template<typename T , std::enable_if_t< indexible< T >, int > = 0>

constexpr auto OpenKalman::is_one_dimensional

(

const T &

t

)

Determine whether T is one_dimensional, meaning that every index has a dimension of 1.

Each index need not have an equivalent coordinates::pattern.

is_square_shaped()

template<typename T , std::enable_if_t< indexible< T >, int > = 0>

constexpr auto OpenKalman::is_square_shaped

(

const T &

t

)

Determine whether an object is square_shaped.

An object is square-shaped if it has the same extents and equivalent coordinates::pattern types for each index (excluding trailing 1D indices). A rank-0 object is square because all indices are implicitly 1D. An empty object in which the first positive n dimensions are 0 is also considered to be square.

Template Parameters

T	A tensor or matrix

Returns

a std::optional which includes the coordinates::pattern object if T is square.

See also

square_shaped

is_vector()

template<std::size_t N = 0, typename T , std::enable_if_t< indexible< T >, int > = 0>

constexpr auto OpenKalman::is_vector

(

const T &

t

)

Return true if T is a vector at runtime.

In this context, a vector is an object in which every index but one is 1D.

Template Parameters

N	An index designating the "large" index (e.g., 0 for a column vector, 1 for a row vector)

See also

vector

LQ_decomposition()

template<typename A , std::enable_if_t< indexible< A > and(not euclidean_transformed< A >), int > = 0>

decltype(auto) constexpr OpenKalman::LQ_decomposition

(

A &&

a

)

Perform an LQ decomposition of matrix A=[L,0]Q, L is a lower-triangular matrix, and Q is orthogonal.

Template Parameters

A	The matrix to be decomposed satisfying triangular_matrix<A, triangle_type::lower>

Returns

L as a lower triangular_matrix which is also square_shaped

make_constant() [1/4]

template<typename C , typename IndexType , std::size_t... Extents, std::enable_if_t< values::value< C >, int > = 0>

constexpr auto OpenKalman::make_constant	(	C	c,
		stdex::extents< IndexType, Extents... >	extents
	)

Make an indexible object in which every element is a constant value.

Returns

An mdspan returning the constant value at every set of indices.

Parameters

c	A value
extents	An std::extents object defining the extents.

make_constant() [2/4]

template<typename C , typename P , std::enable_if_t< values::value< C > and coordinates::pattern_collection< P > and values::fixed< collections::size_of< P >>, int > = 0>

constexpr auto OpenKalman::make_constant	(	C	c,
		P &&	p
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a constant_object based on a pattern_collection.

make_constant() [3/4]

template<typename C , typename... Ps, std::enable_if_t< values::value< C > and(... and coordinates::pattern< Ps >), int > = 0>

constexpr auto OpenKalman::make_constant	(	C	c,
		Ps &&...	ps
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

The pattern_collection is constructed from a list of patterns.

make_constant() [4/4]

template<typename C , typename P , std::enable_if_t< coordinates::pattern_collection< P > and values::value< C > and values::fixed< collections::size_of< P >>, int > = 0>

constexpr auto OpenKalman::make_constant

(

C

c

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a constant_object based on a default-initializable pattern_collection.

make_constant_diagonal() [1/4]

template<typename C , typename IndexType , std::size_t... Extents, std::enable_if_t< values::value< C >, int > = 0>

constexpr auto OpenKalman::make_constant_diagonal	(	C	c,
		stdex::extents< IndexType, Extents... >	extents
	)

Make an indexible object in which every diagonal element is a constant value.

Returns

An mdspan returning the constant value at every set of indices.

Parameters

c	A value
extents	An std::extents object defining the extents.

make_constant_diagonal() [2/4]

template<typename C , typename P , std::enable_if_t< values::value< C > and coordinates::pattern_collection< P > and values::fixed< collections::size_of< P >>, int > = 0>

constexpr auto OpenKalman::make_constant_diagonal	(	C	c,
		P &&	p
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a constant_diagonal_object based on a pattern_collection.

make_constant_diagonal() [3/4]

template<typename C , typename... Ps, std::enable_if_t< values::value< C > and(... and coordinates::pattern< Ps >), int > = 0>

constexpr auto OpenKalman::make_constant_diagonal	(	C	c,
		Ps &&...	ps
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

The pattern_collection is constructed from a list of patterns.

make_constant_diagonal() [4/4]

template<typename C , typename P , std::enable_if_t< coordinates::pattern_collection< P > and values::value< C > and values::fixed< collections::size_of< P >>, int > = 0>

constexpr auto OpenKalman::make_constant_diagonal

(

C

c

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a constant_diagonal_object based on a default-initializable pattern_collection.

make_covariance() [1/6]

template<typename StaticDescriptor , typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and covariance_nestable< Arg > and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< Arg, 0 >::value), int > = 0>

auto OpenKalman::make_covariance ( Arg &&  arg )

inline

Make a Covariance from a covariance_nestable, specifying the fixed_pattern.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
Arg	A covariance_nestable with size matching StaticDescriptor.

Make a Covariance from a self-adjoint typed_matrix_nestable, specifying the coefficients.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
Arg	A square typed_matrix_nestable with size matching StaticDescriptor.

Make a default Axis Covariance (with nested triangular matrix) from a self-adjoint typed_matrix_nestable.

Template Parameters

triangle_type	The type of the nested triangular matrix (upper, lower).
Arg	A square, self-adjoint typed_matrix_nestable.

Make a Covariance, with a nested triangular matrix, from a typed_matrix.

make_covariance() [2/6]

template<typename StaticDescriptor , triangle_type tri, typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and covariance_nestable< Arg > and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< Arg, 0 >::value) and(tri !=triangle_type::lower or triangular_matrix< Arg, triangle_type::lower >) and(tri !=triangle_type::upper or triangular_matrix< Arg, triangle_type::upper >) and(tri !=triangle_type::diagonal or diagonal_matrix< Arg >), int > = 0>

auto OpenKalman::make_covariance ( Arg &&  arg )

inline

Make a Covariance from a covariance_nestable, specifying the fixed_pattern.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
triangle_type	The type of the nested triangular matrix (upper, lower, diagonal).
Arg	A covariance_nestable with size matching StaticDescriptor.

Make a Covariance (with nested triangular matrix) from a self-adjoint typed_matrix_nestable.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
triangle_type	The type of the nested triangular matrix (upper, lower).
Arg	A square, self-adjoint typed_matrix_nestable with size matching StaticDescriptor.

make_covariance() [3/6]

template<typename Arg , std::enable_if_t< covariance_nestable< Arg >, int > = 0>

auto OpenKalman::make_covariance ( Arg &&  arg )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a Covariance from a covariance_nestable, with default Axis coefficients.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
Arg	A covariance_nestable.

Make a Covariance from a self-adjoint typed_matrix_nestable, using default Axis coefficients.

Template Parameters

Arg	A square typed_matrix_nestable.

Make a Covariance based on another non-square-root covariance.

Make a Covariance from a typed_matrix.

make_covariance() [4/6]

template<typename StaticDescriptor , typename Arg , std::enable_if_t<(covariance_nestable< Arg > or typed_matrix_nestable< Arg >) and square_shaped< Arg >, int > = 0>

auto OpenKalman::make_covariance ( )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

For Eigen3: Make a writable, uninitialized Covariance, specifying the fixed_pattern.

For Eigen3: Make a writable, uninitialized Covariance with nested triangular matrix.

For Eigen3: Make a Covariance from a list of coefficients, with default Axis coefficients.

For Eigen3: Make a default Axis Covariance, with nested triangular type, from a list of coefficients.

For Eigen3: Make a Covariance from a list of coefficients, specifying the coefficients.

For Eigen3: Make a Covariance, with nested triangular type, from a list of coefficients.

Make a writable, uninitialized Covariance from a covariance_nestable or typed_matrix_nestable.

Make a writable, uninitialized Covariance based on a nested triangle, with default Axis coefficients.

Make a writable, uninitialized Covariance, with nested triangular type based on a typed_matrix.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
triangle_type	The type of the nested triangular matrix (upper, lower).
Args	A list of numerical coefficients (either integral or floating-point). The number of coefficients must equal coordinates::dimension_of_v<StaticDescriptor> * coordinates::dimension_of_v<StaticDescriptor>.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
Args	A list of numerical coefficients (either integral or floating-point). The number of coefficients must equal coordinates::dimension_of_v<StaticDescriptor> * coordinates::dimension_of_v<StaticDescriptor>.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

triangle_type	The type of the nested triangular matrix (upper, lower).
Args	A list of numerical coefficients (either integral or floating-point). The number of coefficients must be the square of an integer.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

Args	A list of numerical coefficients (either integral or floating-point). The number of coefficients must be the square of an integer.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
triangle_type	The type of the nested triangular matrix (upper, lower).
Scalar	The scalar type (integral or floating-point).

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
Scalar	The scalar type (integral or floating-point).

make_covariance() [5/6]

template<typename StaticDescriptor , triangle_type tri, typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< Arg > and square_shaped< Arg >, int > = 0>

auto OpenKalman::make_covariance ( )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a writable, uninitialized Covariance with a nested triangular matrix, from a typed_matrix_nestable.

make_covariance() [6/6]

template<typename Arg , std::enable_if_t<(covariance_nestable< Arg > or typed_matrix_nestable< Arg >) and square_shaped< Arg >, int > = 0>

auto OpenKalman::make_covariance ( )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a writable, uninitialized Covariance from a typed_matrix_nestable or covariance_nestable.

The coefficients will be Axis.

Make a writable, uninitialized Covariance from a non-square-root covariance.

Make a writable, uninitialized Covariance, based on a typed_matrix.

make_dense_object() [1/2]

template<typename T , data_layout layout = data_layout::none, typename Scalar = scalar_type_of_t<T>, typename Descriptors , std::enable_if_t< indexible< T > and values::number< Scalar > and pattern_collection< D > and(layout !=data_layout::stride) and interface::make_default_defined_for< T, layout, Scalar, decltype(internal::to_euclidean_pattern_collection(std::declval< Descriptors &&>()))>, int > = 0>

constexpr auto OpenKalman::make_dense_object

(

Descriptors &&

descriptors

)

Make a default, dense, writable matrix with a set of coordinates::pattern objects defining the dimensions.

The result will be uninitialized.

Template Parameters

T	A dummy matrix or array from the relevant library (size, shape, and layout are ignored)
layout	The data_layout of the resulting object. If this is data_layout::none, it will be the default layout for the library of T.
Scalar	The scalar type of the resulting object (by default, it is the same scalar type as T).

Parameters

d	a tuple of coordinates::pattern describing dimensions of each index. Trailing 1D indices my be omitted.

make_dense_object() [2/2]

template<typename T , data_layout layout = data_layout::none, typename Scalar = scalar_type_of_t<T>, typename... Ds, std::enable_if_t< indexible< T > and values::number< Scalar > and(... and coordinates::pattern< Ds >) and(layout !=data_layout::stride) and interface::make_default_defined_for< T, layout, Scalar, std::tuple< Ds &&... >>, int > = 0>

constexpr auto OpenKalman::make_dense_object

(

Ds &&...

ds

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

coordinates::pattern object are specified as parameters.

make_dense_object_from() [1/2]

template<typename T , typename layout = stdex::layout_right, typename Scalar = element_type_of_t<T>, typename... Ds, typename... Args, std::enable_if_t< indexible< T > and values::number< Scalar > and(coordinates::pattern< Ds > and ...) and(stdex::convertible_to< Args, const Scalar > and ...) and(stdex::same_as< layout, stdex::layout_right > or stdex::same_as< layout, stdex::layout_left >) and(((coordinates::dimension_of< Ds >::value==0) or ...) ? sizeof...(Args)==0 :(sizeof...(Args) %((dynamic_pattern< Ds > ? 1 :coordinates::dimension_of< Ds >::value) *... *1)==0)), int > = 0>

auto OpenKalman::make_dense_object_from ( const std::tuple< Ds... > &  d_tup, Args...  args  )

inline

Create a dense, writable matrix from the library of which dummy type T is a member, filled with a set of scalar components.

The scalar components are listed in the specified layout order, as follows:

• std::layout_left: column-major;
• std::layout_right: row-major;

  Template Parameters

  T	Any dummy type from the relevant library. Its characteristics are ignored.
  layout	The layout_mapping_policy of Args and the resulting object (std::layout_right by default).
  Scalar	An scalar type for the new matrix. By default, it is the same as T.
  Ds	coordinates::pattern objects describing the size of the resulting object.

  Parameters

  d_tup	A tuple of coordinates::pattern Ds
  args	Scalar values to fill the new matrix.

make_dense_object_from() [2/2]

template<typename T , typename layout = std::compat::layout_right, typename Scalar = element_type_of_t<T>, typename ... Args>

auto OpenKalman::make_dense_object_from ( Args...  args )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Create a dense, writable matrix from a set of components, with size and shape inferred from dummy type T.

The coordinates::pattern of the result must be unambiguously inferrable from T and the number of indices.

Template Parameters

T	The matrix or array on which the new matrix is patterned.
layout	The layout_mapping_policy of Args and the resulting object layout of the resulting object is unspecified).
Scalar	An scalar type for the new matrix. By default, it is the same as T.

Parameters

args	Scalar values to fill the new matrix.

make_diagonal_adapter() [1/2]

template<typename Arg , typename D0 , typename D1 >

constexpr auto OpenKalman::make_diagonal_adapter	(	Arg &&	arg,
		D0 &&	d0,
		D1 &&	d1
	)

Make a diagonal_matrix, specifying the first two dimensions, which may not necessarily be the same.

Template Parameters

Arg	A vector or higher-order tensor reflecting the diagonal(s).
D0	The coordinates::pattern for the rows.
D1	The coordinates::pattern for the columns.

make_diagonal_adapter() [2/2]

template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>

constexpr auto OpenKalman::make_diagonal_adapter

(

Arg &&

arg

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make an square diagonal_matrix that is square with respect to dimensions 0 and 1.

Template Parameters

Arg	A vector or higher-order tensor reflecting the diagonal(s).

make_euclidean_mean() [1/7]

template<typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>

auto OpenKalman::make_euclidean_mean

(

const Args ...

args

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

For Eigen3: Make a one-column EuclideanMean from a list of coefficients, with default Axis coefficients.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

Args	A list of numerical coefficients (either integral or floating-point).

make_euclidean_mean() [2/7]

template<typename Scalar , typename StaticDescriptor , std::size_t cols = 1, std::enable_if_t< values::number< Scalar > and fixed_pattern< StaticDescriptor >, int > = 0>

auto OpenKalman::make_euclidean_mean

(

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

For Eigen3: Make a EuclideanMean based on a scalar type, row coefficients, and a number of columns.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

Scalar	A scalar type (integral or floating-point).
StaticDescriptor	The coefficient types corresponding to the rows.
cols	The number of columns.

make_euclidean_mean() [3/7]

template<typename StaticDescriptor , typename M , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< M > and(coordinates::stat_dimension_of_v< StaticDescriptor >==index_dimension_of< M, 0 >::value), int > = 0>

auto OpenKalman::make_euclidean_mean

(

M &&

arg

)

Make a EuclideanMean from a typed_matrix_nestable, specifying the row coefficients.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows.
M	A typed_matrix_nestable with size matching ColumnCoefficients.

make_euclidean_mean() [4/7]

template<typename M , std::enable_if_t< typed_matrix_nestable< M >, int > = 0>

auto OpenKalman::make_euclidean_mean

(

M &&

m

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a EuclideanMean from a typed_matrix_nestable object, with default Axis coefficients.

make_euclidean_mean() [5/7]

template<typename Arg , std::enable_if_t< typed_matrix< Arg > and has_untyped_index< Arg, 1 >, int > = 0>

auto OpenKalman::make_euclidean_mean ( Arg &&  arg )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a EuclideanMean from another typed_matrix.

Template Parameters

Arg	A typed_matrix (i.e., Matrix, Mean, or EuclideanMean).

make_euclidean_mean() [6/7]

template<typename StaticDescriptor , typename M , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< M > and(coordinates::stat_dimension_of_v< StaticDescriptor >==index_dimension_of< M, 0 >::value), int > = 0>

OpenKalman::make_euclidean_mean

(

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

For Eigen3: Make a EuclideanMean from a list of coefficients, specifying the row coefficients.

Make a default, self-contained EuclideanMean.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows.
M	a typed_matrix_nestable on which the new matrix is based. It will be converted to a self_contained type if it is not already self-contained.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows.
Args	A list of numerical coefficients (either integral or floating-point). The number of coefficients must be divisible by coordinates::stat_dimension_of_v<StaticDescriptor>.

make_euclidean_mean() [7/7]

template<typename M , std::enable_if_t< typed_matrix_nestable< M >, int > = 0>

auto OpenKalman::make_euclidean_mean

(

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a self-contained EuclideanMean with default Axis coefficients.

Template Parameters

M	a typed_matrix_nestable on which the new Euclidean mean is based. It will be converted to a self_contained type if it is not already self-contained.

make_GaussianDistribution() [1/6]

template<typename D , std::enable_if_t< gaussian_distribution< D >, int > = 0>

auto OpenKalman::make_GaussianDistribution ( D &&  dist )

inline

Make a Gaussian distribution.

Template Parameters

D	Another gaussian_distribution.

Returns

A gaussian_distribution.

make_GaussianDistribution() [2/6]

template<typename re = std::mt19937, typename M , typename Cov >

auto OpenKalman::make_GaussianDistribution ( M &&  mean, Cov &&  cov  )

inline

Make a Gaussian distribution.

Template Parameters

re	A random number engine.
M	A typed_matrix.
Cov	A covariance or typed_matrix.

Returns

A gaussian_distribution.

make_GaussianDistribution() [3/6]

template<typename re = std::mt19937, typename M , typename Cov , std::enable_if_t<(not fixed_pattern< re >) and typed_matrix< M > and vector< M > and has_untyped_index< M, 1 > and square_shaped< Cov > and(covariance_nestable< Cov > or typed_matrix_nestable< Cov >) and(index_dimension_of< M, 0 >::value==index_dimension_of< Cov, 0 >::value), int > = 0>

auto OpenKalman::make_GaussianDistribution ( M &&  mean, Cov &&  cov  )

inline

Make a Gaussian distribution.

Template Parameters

re	A random number engine.
M	A typed_matrix.
Cov	A covariance_nestable or typed_matrix_nestable.

Returns

A gaussian_distribution.

Template Parameters

re	A random number engine.
M	A typed_matrix_nestable.
Cov	A covariance, typed_matrix, covariance_nestable, or typed_matrix_nestable.

Returns

A gaussian_distribution.

make_GaussianDistribution() [4/6]

template<typename StaticDescriptor , typename re = std::mt19937, typename M , typename Cov , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< M > and vector< M > and(covariance_nestable< Cov > or typed_matrix_nestable< Cov >), int > = 0>

auto OpenKalman::make_GaussianDistribution ( M &&  mean, Cov &&  cov  )

inline

Make a Gaussian distribution.

Template Parameters

StaticDescriptor	The types of the fixed_pattern for the distribution.
re	A random number engine.
M	A typed_matrix_nestable.
Cov	A covariance_nestable or typed_matrix_nestable.

Returns

A gaussian_distribution.

make_GaussianDistribution() [5/6]

template<typename M , typename Cov , typename re = std::mt19937, std::enable_if_t< typed_matrix< M > and vector< M > and has_untyped_index< M, 1 > and covariance< Cov > and compares_with< vector_space_descriptor_of_t< M, 0 >, vector_space_descriptor_of_t< Cov, 0 >>, int > = 0>

auto OpenKalman::make_GaussianDistribution ( )

inline

Make a default Gaussian distribution.

Template Parameters

M	A typed_matrix.
Cov	A covariance.
re	A random number engine.

Returns

A gaussian_distribution.

Template Parameters

M	A typed_matrix or typed_matrix_nestable.
Cov	A covariance or covariance_nestable.
re	A random number engine.

Returns

A gaussian_distribution.

Note

This overload excludes the case in which M is typed_matrix and Cov is covariance.

make_GaussianDistribution() [6/6]

template<typename StaticDescriptor , typename M , typename Cov , typename re = std::mt19937, std::enable_if_t< typed_matrix_nestable< M > and vector< M > and covariance_nestable< Cov > and(index_dimension_of< M, 0 >::value==index_dimension_of< Cov, 0 >::value), int > = 0>

auto OpenKalman::make_GaussianDistribution ( )

inline

Make a default Gaussian distribution.

Template Parameters

StaticDescriptor	The types of the fixed_pattern for the distribution.
M	A typed_matrix_nestable
Cov	A covariance_nestable.
re	A random number engine

Returns

A gaussian_distribution

make_hermitian_matrix()

template<HermitianAdapterType adapter_type = HermitianAdapterType::lower, typename Arg , std::enable_if_t< square_shaped< Arg, applicability::permitted > and(adapter_type==HermitianAdapterType::lower or adapter_type==HermitianAdapterType::upper), int > = 0>

decltype(auto) constexpr OpenKalman::make_hermitian_matrix

(

Arg &&

arg

)

Creates a hermitian_matrix by, if necessary, wrapping the argument in a hermitian_adapter.

Note

The result is guaranteed to be hermitian, but is not guaranteed to be an adapter or have the requested adapter_type.

Template Parameters

adapter_type	The intended HermitianAdapterType of the result (lower op upper).
Arg	A square matrix.

make_identity_matrix_like() [1/4]

template<typename T , typename Scalar = typename scalar_type_of<T>::type, typename Descriptors , std::enable_if_t< indexible< T > and values::number< Scalar > and pattern_collection< Descriptors >, int > = 0>

constexpr auto OpenKalman::make_identity_matrix_like

(

Descriptors &&

descriptors

)

Make an identity_matrix with a particular set of coordinates::pattern objects.

Template Parameters

T	Any matrix or tensor within the relevant library.
Scalar	An optional scalar type for the new zero matrix. By default, T's scalar type is used.

Parameters

Ds	A set of coordinates::pattern items defining the dimensions of each index.

make_identity_matrix_like() [2/4]

template<typename T , typename Scalar = typename scalar_type_of<T>::type, typename... Ds, std::enable_if_t< indexible< T > and values::number< Scalar > and(... and coordinates::pattern< Ds >), int > = 0>

constexpr auto OpenKalman::make_identity_matrix_like

(

Ds &&...

ds

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

coordinates::pattern objects are passed as arguments.

make_identity_matrix_like() [3/4]

template<typename Scalar , typename Arg , std::enable_if_t< values::number< Scalar > and indexible< Arg >, int > = 0>

constexpr auto OpenKalman::make_identity_matrix_like

(

Arg &&

arg

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make an identity matrix with the same size and shape as an argument, specifying a new scalar type.

Template Parameters

Arg	The matrix or array on which the new identity matrix is patterned. It need not be square.
Scalar	A scalar type for the new matrix.

Returns

An identity matrix of the same dimensions as Arg (even if not square).

make_identity_matrix_like() [4/4]

template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>

constexpr auto OpenKalman::make_identity_matrix_like

(

Arg &&

arg

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make an identity matrix with the same size and shape as an argument.

Template Parameters

Arg	The matrix or array on which the new zero matrix is patterned.

Returns

An identity matrix of the same dimensions as Arg (even if not square).

make_matrix() [1/2]

template<typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>

auto OpenKalman::make_matrix

(

const Args ...

args

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

For Eigen3: Make a one-column Matrix from a list of coefficients, with default Axis coefficients.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

Args	A list of numerical coefficients (either integral or floating-point).

make_matrix() [2/2]

template<typename Scalar , typename RowCoefficients , typename ColumnCoefficients = RowCoefficients, std::enable_if_t< values::number< Scalar > and fixed_pattern< RowCoefficients > and fixed_pattern< ColumnCoefficients >, int > = 0>

OpenKalman::make_matrix

(

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

For Eigen3: Make a Matrix from a list of coefficients, specifying the row and column coefficients.

For Eigen3: Make a Matrix based on a scalar type and row and column coefficients.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

Scalar	A scalar type (integral or floating-point).
RowCoefficients	The coefficient types corresponding to the rows.
ColumnCoefficients	The coefficient types corresponding to the columns.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

RowCoefficients	The coefficient types corresponding to the rows.
ColumnCoefficients	The coefficient types corresponding to the columns.
Args	A list of numerical coefficients (either integral or floating-point). The number of coefficients must equal coordinates::dimension_of_v<RowCoefficients> * coordinates::dimension_of_v<ColumnCoefficients>.

make_mean() [1/7]

template<typename ... Args, std::enable_if_t<(sizeof...(Args) > 0>

auto OpenKalman::make_mean

(

const Args ...

args

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

For Eigen3: Make a one-column Mean from a list of coefficients, with default Axis coefficients.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

Args	A list of numerical coefficients (either integral or floating-point).

make_mean() [2/7]

template<typename Scalar , typename StaticDescriptor , std::size_t cols = 1, std::enable_if_t< values::number< Scalar > and fixed_pattern< StaticDescriptor >, int > = 0>

auto OpenKalman::make_mean

(

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

For Eigen3: Make a Mean based on a scalar type, a set of row coefficients, and a number of columns.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

Scalar	A scalar type (integral or floating-point).
StaticDescriptor	The coefficient types corresponding to the rows.
cols	The number of columns.

make_mean() [3/7]

template<typename StaticDescriptor , typename M , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< M > and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< M, 0 >::value), int > = 0>

auto OpenKalman::make_mean ( M &&  m )

inline

Make a Mean from a typed_matrix_nestable, specifying the row fixed_pattern.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows.
M	A typed_matrix_nestable with size matching ColumnCoefficients.

make_mean() [4/7]

template<typename M , std::enable_if_t< typed_matrix_nestable< M >, int > = 0>

auto OpenKalman::make_mean ( M &&  m )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a Mean from a typed_matrix_nestable object, with default Axis fixed_pattern.

make_mean() [5/7]

template<typename Arg , std::enable_if_t< typed_matrix< Arg > and has_untyped_index< Arg, 1 >, int > = 0>

auto OpenKalman::make_mean ( Arg &&  arg )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a Mean from another typed_matrix.

Template Parameters

Arg	A typed_matrix (i.e., Matrix, Mean, or EuclideanMean).

make_mean() [6/7]

template<typename StaticDescriptor , typename M , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< M > and(index_dimension_of< M, 0 >::value==coordinates::dimension_of_v< StaticDescriptor >), int > = 0>

OpenKalman::make_mean ( )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

For Eigen3: Make a Mean from a list of coefficients, specifying the row coefficients.

Make a default, self-contained Mean.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows.
M	a typed_matrix_nestable on which the new matrix is based. It will be converted to a self_contained type if it is not already self-contained.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows.
Args	A list of numerical coefficients (either integral or floating-point). The number of coefficients must be divisible by coordinates::dimension_of_v<StaticDescriptor>.

make_mean() [7/7]

template<typename M , std::enable_if_t< typed_matrix_nestable< M >, int > = 0>

auto OpenKalman::make_mean ( )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a self-contained Mean with default Axis fixed_pattern.

Template Parameters

M	a typed_matrix_nestable on which the new mean is based. It will be converted to a self_contained type if it is not already self-contained.

make_square_root_covariance() [1/6]

template<typename StaticDescriptor , typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and covariance_nestable< Arg > and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< Arg, 0 >::value), int > = 0>

auto OpenKalman::make_square_root_covariance ( Arg &&  arg )

inline

Make a SquareRootCovariance from a covariance_nestable, specifying the coefficients.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
Arg	A covariance_nestable with size matching StaticDescriptor.

Make a default Axis SquareRootCovariance from a self-adjoint typed_matrix_nestable.

Template Parameters

triangle_type	The type of the nested triangular matrix (upper, lower).
Arg	A square, self-adjoint typed_matrix_nestable.

Make a SquareRootCovariance from a typed_matrix.

make_square_root_covariance() [2/6]

template<typename Arg , std::enable_if_t< covariance_nestable< Arg >, int > = 0>

auto OpenKalman::make_square_root_covariance ( Arg &&  arg )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a SquareRootCovariance from a covariance_nestable, with default Axis coefficients.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
Arg	A covariance_nestable.

Make a SquareRootCovariance based on another triangular_covariance.

make_square_root_covariance() [3/6]

template<typename StaticDescriptor , triangle_type tri = triangle_type::lower, typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< Arg > and(not covariance_nestable< Arg >) and(tri==triangle_type::lower or tri==triangle_type::upper) and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< Arg, 0 >::value) and(coordinates::dimension_of_v< StaticDescriptor >==index_dimension_of< Arg, 1 >::value), int > = 0>

auto OpenKalman::make_square_root_covariance ( Arg &&  arg )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a SquareRootCovariance (with nested triangular matrix) from a self-adjoint typed_matrix_nestable.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
triangle_type	The type of the nested triangular matrix (upper, lower).
Arg	A square, self-adjoint typed_matrix_nestable with size matching StaticDescriptor.

make_square_root_covariance() [4/6]

template<typename StaticDescriptor , triangle_type tri, typename Arg , std::enable_if_t< fixed_pattern< StaticDescriptor > and typed_matrix_nestable< Arg > and square_shaped< Arg >, int > = 0>

auto OpenKalman::make_square_root_covariance ( )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

For Eigen3: Make a writable, uninitialized SquareRootCovariance.

For Eigen3: Make a default Axis SquareRootCovariance from a list of coefficients.

For Eigen3: Make a SquareRootCovariance from a list of coefficients.

Make a writable, uninitialized SquareRootCovariance from a typed_matrix_nestable.

Only the coefficients in the associated upper or lower triangle are significant.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
triangle_type	The type of the nested triangular matrix (upper, lower).
Args	A list of numerical coefficients (either integral or floating-point). The number of coefficients must equal coordinates::dimension_of_v<StaticDescriptor> * coordinates::dimension_of_v<StaticDescriptor>.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

triangle_type	The type of the nested triangular matrix (upper, lower).
Args	A list of numerical coefficients (either integral or floating-point). The number of coefficients must be the square of an integer.

Note

This function is imported into the OpenKalman namespace if Eigen3 is the first-included interface.

Template Parameters

StaticDescriptor	The coefficient types corresponding to the rows and columns.
triangle_type	The type of the nested triangular matrix (upper, lower).
Scalar	The scalar type (integral or floating-point).

make_square_root_covariance() [5/6]

template<typename StaticDescriptor , typename Arg , std::enable_if_t<(covariance_nestable< Arg > or typed_matrix_nestable< Arg >) and square_shaped< Arg >, int > = 0>

auto OpenKalman::make_square_root_covariance ( )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a writable, uninitialized SquareRootCovariance from a covariance_nestable or typed_matrix_nestable.

Make a writable, uninitialized SquareRootCovariance, with default Axis coefficients.

Make a writable, uninitialized SquareRootCovariance based on a typed_matrix.

make_square_root_covariance() [6/6]

template<typename Arg , std::enable_if_t<(covariance_nestable< Arg > or typed_matrix_nestable< Arg >) and square_shaped< Arg >, int > = 0>

auto OpenKalman::make_square_root_covariance ( )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Make a writable, uninitialized SquareRootCovariance from a typed_matrix_nestable or covariance_nestable.

The coefficients will be Axis.

Make a writable, uninitialized SquareRootCovariance from a triangular_covariance.

Make a writable, uninitialized SquareRootCovariance based on a typed_matrix.

make_triangular_matrix()

template<triangle_type t = triangle_type::lower, typename Arg , std::enable_if_t< indexible< Arg > and(t==triangle_type::lower or t==triangle_type::upper or t==triangle_type::diagonal), int > = 0>

decltype(auto) constexpr OpenKalman::make_triangular_matrix

(

Arg &&

arg

)

Create a triangular_matrix from a general matrix.

Template Parameters

t	The intended triangle_type of the result.
Arg	A general matrix to be made triangular.

make_zero()

template<typename C = double, typename IndexType , std::size_t... Extents, std::enable_if_t< values::value< C >, int > = 0>

constexpr auto OpenKalman::make_zero

(

stdex::extents< IndexType, Extents... >

extents

)

Make an indexible object in which every element is 0.

Returns

An mdspan returning the constant value at every set of indices.

Parameters

extents

An std::extents object defining the extents.

Matrix()

template<typename V , std::enable_if_t< typed_matrix< V > and not euclidean_transformed< V >, int > = 0>

OpenKalman::Matrix

(

V &&

)

-> Matrix< vector_space_descriptor_of_t< V, 0 >, vector_space_descriptor_of_t< V, 1 >, passable_t< nested_object_of_t< V >>>

Deduce template parameters from a non-Euclidean-transformed typed matrix.

Deduce parameter types from a Covariance.

Deduce template parameters from a Euclidean-transformed typed matrix.

Mean()

template<typename V , std::enable_if_t< typed_matrix_nestable< V >, int > = 0>

OpenKalman::Mean ( V &&  ) -> Mean< Dimensions< index_dimension_of_v< V, 0 >>, passable_t< V >>

explicit

Deduce template parameters from a typed_matrix_nestable, assuming untyped coordinates::pattern.

Deduce template parameters from a Euclidean-transformed typed matrix.

Deduce template parameters from a non-Euclidean-transformed typed matrix.

n_ary_operation() [1/4]

template<typename... Ds, typename Operation , typename... Args, std::enable_if_t<(coordinates::pattern< Ds > and ...) and(indexible< Args > and ...) and(sizeof...(Args) > 0>

constexpr auto OpenKalman::n_ary_operation	(	const std::tuple< Ds... > &	d_tup,
		Operation &&	operation,
		Args &&...	args
	)

Perform a component-wise n-ary operation, using broadcasting to match the size of a pattern matrix.

This overload is for unary, binary, and higher n-ary operations. Examples:

• Unary operation, no broadcasting:

  auto ds32 = std::tuple {Dimensions<3>{}, Dimensions<2>{}};
  auto op1 = [](auto arg){return 3 * arg;};
  auto M = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
  auto m32 = make_dense_object_from<M>(ds32, 1, 2, 3, 4, 5, 6);
  std::cout << n_ary_operation(ds32, op1, m32) << std::endl;

  Output:

  3, 6,
  9, 12,
  15, 18

• Unary operation, broadcasting:

  auto ds31 = std::tuple {Dimensions<3>{}, Dimensions<1>{}};
  auto m31 = make_dense_object_from<M>(ds31, 1, 2, 3);
  std::cout << n_ary_operation(ds32, op1, m31) << std::endl;

  Output:

  3, 3,
  6, 6,
  9, 9

• Binary operation, no broadcasting:

  auto op2 = [](auto arg1, auto arg2){return 3 * arg1 + arg2;};
  std::cout << n_ary_operation(ds32, op2, m32, 2 * m32) << std::endl;

  Output:

  5, 10,
  15, 20,
  25, 30

• Binary operation, broadcasting:

  std::cout << n_ary_operation(ds32, op2, m31, 2 * m32) << std::endl;

  Output:

  5, 7,
  12, 14,
  19, 21

• Binary operation, broadcasting, with indices:

  auto op2b = [](auto arg1, auto arg2, std::size_t row, std::size_t col){return 3 * arg1 + arg2 + row + col;};
  std::cout << n_ary_operation(ds32, op2b, m31, 2 * m32) << std::endl;

  Output:

  5, 8,
  13, 16,
  21, 24

  Template Parameters

  Ds	coordinates::pattern objects defining the size of the result.
  Operation	The n-ary operation taking n arguments and, optionally, a set of indices indicating the location within the result. The operation must return a scalar value.
  Args	The arguments

  Returns

  A matrix or array in which each component is the result of calling Operation on corresponding components from each of the arguments, in the order specified.

n_ary_operation() [2/4]

template<typename Operation , typename... Args, std::enable_if_t<(indexible< Args > and ...) and(sizeof...(Args) > 0>

constexpr auto OpenKalman::n_ary_operation	(	Operation &&	operation,
		Args &&...	args
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Perform a component-wise n-ary operation, using broadcasting if necessary to make the arguments the same size.

Each of the arguments may be expanded by broadcasting. The result will derive each dimension from the largest corresponding dimension among the arguments. Examples:

• Binary operation, broadcasting:

  auto M = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
  auto op2a = [](auto arg1, auto arg2){return 3 * arg1 + arg2;};
  auto m31 = make_dense_object_from<M>(ds31, 1, 2, 3);
  auto m32 = make_dense_object_from<M>(ds32, 1, 2, 3, 4, 5, 6);
  std::cout << n_ary_operation(op2a, m31, 2 * m32) << std::endl;

  Output:

  5, 7,
  12, 14,
  19, 21

• Binary operation, broadcasting, with indices:

  auto op2b = [](auto arg1, auto arg2, std::size_t row, std::size_t col){return 3 * arg1 + arg2 + row + col;};
  std::cout << n_ary_operation(op2b, m31, 2 * m32) << std::endl;

  Output:

  5, 8,
  13, 16,
  21, 24

• Unary operation, with indices:

  auto op1a = [](auto& arg, std::size_t row, std::size_t col){return arg + row + col;};
  std::cout << n_ary_operation(op1a, m32) << std::endl;

  Output:

  1, 3,
  4, 6,
  7, 9

  Template Parameters

  Operation	The n-ary operation taking n arguments and, optionally, a set of indices. The operation must return a scalar value.
  Args	The arguments

  Returns

  A matrix or array in which each component is the result of calling Operation on corresponding components from each of the arguments, in the order specified.

n_ary_operation() [3/4]

template<typename PatternMatrix , std::size_t... indices, typename... Ds, typename... Operations>

constexpr auto OpenKalman::n_ary_operation	(	const std::tuple< Ds... > &	d_tup,
		const Operations &...	operations
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Perform a component-wise nullary operation with potentially multiple operations for different blocks.

Examples:

• One operation for the entire matrix

  auto ds23 = std::tuple {Dimensions<2>{}, Dimensions<3>{}};
  auto M = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
  std::cout << n_ary_operation<M>(ds23, [](auto arg){return 7;}) << std::endl;

  Output:

  7, 7, 7,
  7, 7, 7

• One operation for each element

  std::cout << n_ary_operation<M, 0, 1>(ds23, []{return 4;}, []{return 5;}, []{return 6;}, []{return 7;}, []{return 8;}, []{return 9;});

  Output:

  4, 5, 6,
  7, 8, 9

• One operation for each row

  auto ds23a = std::tuple {Dimensions<2>{}, Dimensions{3}};
  std::cout << n_ary_operation<M, 0>(ds23a, []{return 5;}, []{return 6;});

  Output:

  5, 5, 5,
  6, 6, 6

• One operation for each column

  auto ds23b = std::tuple {Dimensions{2}, Dimensions<3>{}};
  std::cout << n_ary_operation<M, 1>(ds23b, []{return 5;}, []{return 6;}, []{return 7;});

  Output:

  5, 6, 7,
  5, 6, 7

• One operation for each column, with indices

  auto ds23b = std::tuple {Dimensions{2}, Dimensions<3>{}};
  auto op1 = [](std::size_t r, std::size_t c){ return 5 + r + c; };
  auto op2 = [](std::size_t r, std::size_t c){ return 6 + r + c; };
  auto op3 = [](std::size_t r, std::size_t c){ return 7 + r + c; };
  std::cout << n_ary_operation<M, 1>(ds23b, []{return 5;}, []{return 6;}, []{return 7;});

  Output:

  5, 7, 9,
  6, 8, 10

  Template Parameters

  PatternMatrix	A matrix or array corresponding to the result type. Its purpose is to indicate the library from which to create a resulting matrix, and its dimensions need not match the specified dimensions Ds
  indices	The indices, if any, along which there will be a different operator for each element along that index.
  Ds	coordinates::pattern objects for each index of the result. coordinates::pattern objects corresponding to indices must be of a fixed_pattern type.
  Operations	The nullary operations. The number of operations must equal the product of each dimension Ds corresponding to indices. The order of the operations depends on the order of indices, with the left-most index being the most major, and the right-most index being the most minor. For example, if indices are {0, 1} for a matrix result, the operations must be in row-major order. If the indices are {1, 0}, the operations must be in column-major order. Each operation may be invocable with no arguments or invocable with as many indices as there are coordinates::pattern Ds. (If the index corresponds to one of designaged indices, then the operation will be called with std::integral_constant<std::size_t, index>{} for that index, instead of std::size_t.))

  Returns

  A matrix or array in which each component is the result of calling Operation and which has dimensions corresponding to Ds

n_ary_operation() [4/4]

template<typename PatternMatrix , std::size_t... indices, typename... Ds, typename... Operations, std::enable_if_t< indexible< PatternMatrix > and(coordinates::pattern< Ds > and ...) and((not dynamic_dimension< PatternMatrix, indices >) and ...) and(sizeof...(Operations)==(1 *... *index_dimension_of< PatternMatrix, indices >::value)), int > = 0>

constexpr auto OpenKalman::n_ary_operation

(

const Operations &...

operations

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Perform a component-wise nullary operation, deriving the resulting size from a pattern matrix.

• One operation for the entire matrix

  auto M = Eigen::Matrix<double, 2, 3>
  std::cout << n_ary_operation<M>([](auto arg){return 7;}) << std::endl;

  Output:

  7, 7, 7,
  7, 7, 7

• One operation for each element

  std::cout << n_ary_operation<M, 0, 1>([]{return 4;}, []{return 5;}, []{return 6;}, []{return 7;}, []{return 8;}, []{return 9;});

  Output:

  4, 5, 6,
  7, 8, 9

• One operation for each row

  std::cout << n_ary_operation<M, 0>([]{return 5;}, []{return 6;});

  Output:

  5, 5, 5,
  6, 6, 6

• One operation for each column

  std::cout << n_ary_operation<M, 1>([]{return 5;}, []{return 6;}, []{return 7;});

  Output:

  5, 6, 7,
  5, 6, 7

  Template Parameters

  PatternMatrix	A matrix or array corresponding to the result type. Its purpose is to indicate the library from which to create a resulting matrix, and its dimensions need not match the specified dimensions Ds. Dimensions of PatternMatrix corresponding to indices must be of a fixed_pattern type.
  indices	The indices, if any, along which there will be a different operator for each element along that index.
  Operations	The nullary operations. The number of operations must equal the product of each dimension Ds corresponding to indices.

  Returns

  A matrix or array in which each component is the result of calling Operation and which has dimensions corresponding to Ds

nested_object()

template<typename Arg , std::enable_if_t< has_nested_object< Arg >, int > = 0>

decltype(auto) constexpr OpenKalman::nested_object

(

Arg &&

arg

)

Retrieve a nested object of Arg, if it exists.

Template Parameters

i	Index of the nested matrix (0 for the 1st, 1 for the 2nd, etc.).
Arg	A wrapper that has at least one nested object.

patterns_match()

template<typename... Ts, std::enable_if_t<(indexible< Ts > and ...), int > = 0>

constexpr bool OpenKalman::patterns_match

(

const Ts &...

ts

)

Return true if every set of coordinates::pattern of a set of objects are equivalent.

Template Parameters

Ts	A set of tensors or matrices

See also

patterns_match_with

patterns_may_match_with

QR_decomposition()

template<typename A , std::enable_if_t< indexible< A >, int > = 0>

decltype(auto) constexpr OpenKalman::QR_decomposition

(

A &&

a

)

Perform a QR decomposition of matrix A=Q[U,0], U is a upper-triangular matrix, and Q is orthogonal.

Template Parameters

A	The matrix to be decomposed

Returns

U as an upper triangular_matrix

randomize() [1/6]

template<typename PatternMatrix , std::size_t... indices, typename random_number_generator , typename... Ds, typename... Dists>

constexpr auto OpenKalman::randomize	(	random_number_generator &	gen,
		const std::tuple< Ds... > &	ds_tuple,
		Dists &&...	dists
	)

Create an indexible object with random values selected from one or more random distributions.

This is essentially a specialized version of n_ary_operation with the nullary operator being a randomization function. The distributions are allocated to each element of the object, according to one of the following options:

• One distribution for all elements. The following example constructs a 2-by-2 matrix (m) in which each element is a random value selected based on a distribution with mean 1.0 and standard deviation 0.3:

  using N = std::normal_distribution<double>;
  using Mat = Eigen::Matrix<double, 2, 2>;
  auto g = std::mt19937 {};
  Mat m = randomize<Mat>(g, std::tuple {2, 2}, N {1.0, 0.3}));

• One distribution for each element. The following code constructs a 2-by-2 matrix m containing random values around mean 1.0, 2.0, 3.0, and 4.0 (in row-major order), with standard deviations of 0.3, 0.3, 0.0 (by default, since no s.d. is specified as a parameter), and 0.3:

  using N = std::normal_distribution<double>;
  auto m = randomize<Eigen::Matrix<double, 2, 2>, 0, 1>(g,
    std::tuple {Dimensions<2>{}, Dimensions<2>{}}, N {1.0, 0.3}, N {2.0, 0.3}, 3.0, N {4.0, 0.3})));

• One distribution for each row. The following code constructs a 3-by-2 (n) or 2-by-2 (o) matrices in which elements in each row are selected according to the three (n) or two (o) listed distribution parameters:

  auto n = randomize<Eigen::Matrix<double, 3, 2>, 0>(g, std::tuple {Dimensions<3>{}, 2},
    N {1.0, 0.3}, 2.0, N {3.0, 0.3})));
  auto o = randomize<Eigen::Matrix<double, 2, 2>, 0>(g, std::tuple {Dimensions<2>{}, 2},
    N {1.0, 0.3}, N {2.0, 0.3})));

• One distribution for each column. The following code constructs 2-by-3 matrix p in which elements in each column are selected according to the three listed distribution parameters:

  auto p = randomize<Eigen::Matrix<double, 2, 3>, 1>(g, std::tuple {2, Dimensions<3>{}},
    N {1.0, 0.3}, 2.0, N {3.0, 0.3})));

  Template Parameters

  PatternMatrix	An indexible object corresponding to the result type. Its dimensions need not match the specified dimensions Ds
  indices	The indices, if any, for which there is a distinct distribution. If not provided, this can in some cases be inferred from the number of Dists provided.
  random_number_generator	The random number generator (e.g., std::mt19937).
  Ds	coordinates::pattern objects for each index the result. They need not correspond to the dimensions of PatternMatrix.
  Dists	One or more distributions (e.g., std::normal_distribution<double>)

  See also

  n_ary_operation

randomize() [2/6]

template<typename PatternMatrix , std::size_t... indices, typename... Ds, typename... Dists>

constexpr auto OpenKalman::randomize	(	const std::tuple< Ds... > &	d_tuple,
		Dists &&...	dists
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Create an indexible object with random values, using std::mt19937 as the random number engine.

randomize() [3/6]

template<typename PatternMatrix , std::size_t... indices, typename random_number_generator , typename... Dists, std::enable_if_t< indexible< PatternMatrix > and(not has_dynamic_dimensions< PatternMatrix >) and(sizeof...(Dists)==(1 *... *index_dimension_of< PatternMatrix, indices >::value)) and((std::is_arithmetic_v< Dists > or detail::is_std_dist< Dists >::value) and ...), int > = 0>

constexpr auto OpenKalman::randomize	(	random_number_generator &	gen,
		Dists &&...	dists
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Fill a fixed-sized indexible object with random values selected from one or more random distributions.

The distributions are allocated to each element of the matrix, according to one of the following options:

• One distribution for all matrix elements. The following example constructs a 2-by-2 matrix (m) in which each element is a random value selected based on a distribution with mean 1.0 and standard deviation 0.3:

  using N = std::normal_distribution<double>;
  using Mat = Eigen::Matrix<double, 2, 2>;
  auto g = std::mt19937 {};
  Mat m = randomize<Mat>(N {1.0, 0.3}));

• One distribution for each matrix element. The following code constructs a 2-by-2 matrix m containing random values around mean 1.0, 2.0, 3.0, and 4.0 (in row-major order), with standard deviations of 0.3, 0.3, 0.0 (by default, since no s.d. is specified as a parameter), and 0.3:

  using N = std::normal_distribution<double>;
  auto m = randomize<Eigen::Matrix<double, 2, 2>, 0, 1>(g, N {1.0, 0.3}, N {2.0, 0.3}, 3.0, N {4.0, 0.3})));

• One distribution for each row. The following code constructs a 3-by-2 (n) or 2-by-2 (o) matrices in which elements in each row are selected according to the three (n) or two (o) listed distribution parameters:

  auto n = randomize<Eigen::Matrix<double, 3, 2>, 0>(g, N {1.0, 0.3}, 2.0, N {3.0, 0.3})));
  auto o = randomize<Eigen::Matrix<double, 2, 2>, 0>(g, N {1.0, 0.3}, N {2.0, 0.3})));

• One distribution for each column. The following code constructs 2-by-3 matrix p in which elements in each column are selected according to the three listed distribution parameters:

  auto p = randomize<Eigen::Matrix<double, 2, 3>, 1>(g, N {1.0, 0.3}, 2.0, N {3.0, 0.3})));

  Template Parameters

  PatternMatrix	A fixed-size matrix
  random_number_generator	The random number generator (e.g., std::mt19937).

randomize() [4/6]

template<typename PatternMatrix , std::size_t... indices, typename... Dists, std::enable_if_t< indexible< PatternMatrix > and(not has_dynamic_dimensions< PatternMatrix >) and(sizeof...(Dists)==(1 *... *index_dimension_of< PatternMatrix, indices >::value)) and((std::is_arithmetic_v< Dists > or detail::is_std_dist< Dists >::value) and ...), int > = 0>

constexpr auto OpenKalman::randomize

(

Dists &&...

dists

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Fill a fixed-sized indexible object with random values using std::mt19937 as the random number generator.

randomize() [5/6]

template<typename ReturnType , typename random_number_engine = std::mt19937, typename... Dists, std::enable_if_t< typed_matrix< ReturnType > and(not has_dynamic_dimensions< ReturnType >) and(sizeof...(Dists) > 0>

auto OpenKalman::randomize ( Dists &&...  dists )

inline

Fill a fixed-shape typed matrix with random values selected from a random distribution.

The distributions are allocated to each element of the matrix, according to one of the following options:

• One distribution for the entire matrix. The following example constructs a 2-by-2 matrix (m) in which each element is a random value selected based on a distribution with mean 1.0 and standard deviation 0.3:

  using N = std::normal_distribution<double>;
  auto m = randomize<Matrix<Dimensions<2>, Dimensions<2>, Eigen::Matrix<double, 2, 2>>>(N {1.0, 0.3}));

• One distribution for each matrix element. The following code constructs a 2-by-2 matrix n containing random values around mean 1.0, 2.0, 3.0, and 4.0 (in row-major order), with standard deviations of 0.3, 0.3, 0.0 (by default, since no s.d. is specified as a parameter), and 0.3:

  auto n = randomize<Matrix<Dimensions<2>, Dimensions<2>, Eigen::Matrix<double, 2, 2>>>(N {1.0, 0.3}, N {2.0, 0.3}, 3.0, N {4.0, 0.3})));

• One distribution for each row. The following code constructs a 3-by-2 (o) or 2-by-2 (p) matrices in which elements in each row are selected according to the three (o) or two (p) listed distribution parameters:

  auto o = randomize<Matrix<Dimensions<3>, std::array<angle::Radians, 2>, Eigen::Matrix<double, 3, 2>>>(N {1.0, 0.3}, 2.0, N {3.0, 0.3})));
  auto p = randomize<Matrix<Dimensions<2>, std::array<angle::Radians, 2>, Eigen::Matrix<double, 2, 2>>>(N {1.0, 0.3}, N {2.0, 0.3})));

  Note that in the case of p, there is an ambiguity as to whether the listed distributions correspond to rows or columns. In case of such an ambiguity, this function assumes that the parameters correspond to the rows.
• One distribution for each column. The following code constructs 2-by-3 matrix m in which elements in each column are selected according to the three listed distribution parameters:

  auto m = randomize<Matrix<std::tuple<angle::Radians, angle::Radians>, Dimensions<3>, Eigen::Matrix<double, 2, 3>>>(N {1.0, 0.3}, 2.0, N {3.0, 0.3})));

Template Parameters

ReturnType	The return type reflecting the size of the matrix to be filled. The actual result will be a fixed typed matrix.
random_number_engine	The random number engine.
Dists	A set of distributions (e.g., std::normal_distribution<double>) or, alternatively, means (a definite, non-stochastic value).

randomize() [6/6]

template<typename ReturnType , typename random_number_engine = std::mt19937, typename Dist >

auto OpenKalman::randomize ( const std::size_t  rows, const std::size_t  columns, Dist &&  dist  )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Fill a dynamic-shape typed_matrix with random values selected from a single random distribution.

The following example constructs two 2-by-2 matrices (m, n, and p) in which each element is a random value selected based on a distribution with mean 1.0 and standard deviation 0.3:

auto m = randomize<Matrix<Dimensions<2>, Dimensions<2>, Eigen::Matrix<float, 2, Eigen::Dynamic>>>(2, 2, std::normal_distribution<float> {1.0, 0.3}));
auto n = randomize<Matrix<Dimensions<2>, Dimensions<2>, Eigen::Matrix<double, Eigen::Dynamic, 2>>>(2, 2, std::normal_distribution<double> {1.0, 0.3}));
auto p = randomize<Matrix<Dimensions<2>, Dimensions<2>, Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>>(2, 2, std::normal_distribution<double> {1.0, 0.3});

Template Parameters

ReturnType	The type of the matrix to be filled.
random_number_engine	The random number engine (e.g., std::mt19937).

Parameters

rows	Number of rows, decided at runtime. Must match rows of ReturnType if they are fixed.
columns	Number of columns, decided at runtime. Must match columns of ReturnType if they are fixed.

Template Parameters

Dist	A distribution (type distribution_type).

rank_update_hermitian()

template<typename A , typename U , std::enable_if_t< indexible< U > and hermitian_matrix< A, applicability::permitted > and dimension_size_of_index_is< U, 0, index_dimension_of< A, 0 >::value, applicability::permitted > and dimension_size_of_index_is< U, 0, index_dimension_of< A, 1 >::value, applicability::permitted > and stdex::convertible_to< typename scalar_type_of< U >::type, const typename scalar_type_of< A >::type >, int > = 0>

decltype(auto) OpenKalman::rank_update_hermitian ( A &&  a, U &&  u, scalar_type_of_t< A >  alpha = 1  )

inline

Do a rank update on a hermitian matrix.

Note

This may (or may not) be performed as an in-place operation if argument A is writable and hermitian.

The update is A += αUU^*, returning the updated hermitian A. If A is an lvalue reference, hermitian, and writable, it will be updated in place and the return value will be an lvalue reference to the same, updated A. Otherwise, the function returns a new matrix.

Template Parameters

A	The hermitian matrix to be rank updated.
U	The update vector or matrix.

Returns

an updated native, writable matrix in hermitian form.

rank_update_triangular()

template<typename A , typename U , std::enable_if_t< triangular_matrix< A, triangle_type::any > and indexible< U > and dimension_size_of_index_is< U, 0, index_dimension_of< A, 0 >::value, applicability::permitted > and dimension_size_of_index_is< U, 0, index_dimension_of< A, 1 >::value, applicability::permitted > and stdex::convertible_to< scalar_type_of_t< U >, const scalar_type_of_t< A >>, int > = 0>

decltype(auto) OpenKalman::rank_update_triangular ( A &&  a, U &&  u, scalar_type_of_t< A >  alpha = 1  )

inline

Do a rank update on triangular matrix.

Note

This may (or may not) be performed as an in-place operation if argument A is writable.

• If A is lower-triangular, diagonal, or one-by-one, the update is AA^* += αUU^*, returning the updated A.
• If A is upper-triangular, the update is A^*A += αUU^*, returning the updated A.
• If A is an lvalue reference and is writable, it will be updated in place and the return value will be an lvalue reference to the same, updated A. Otherwise, the function returns a new matrix.

  Template Parameters

  A	The matrix to be rank updated.
  U	The update vector or matrix.

  Returns

  an updated native, writable matrix in triangular (or diagonal) form.

reduce() [1/2]

template<std::size_t index, std::size_t... indices, typename BinaryFunction , typename Arg , std::enable_if_t< internal::has_uniform_patterns< Arg, index, indices... > and std::is_invocable_r< typename scalar_type_of< Arg >::type, BinaryFunction &&, typename scalar_type_of< Arg >::type, typename scalar_type_of< Arg >::type >::value, int > = 0>

decltype(auto) constexpr OpenKalman::reduce	(	BinaryFunction &&	b,
		Arg &&	arg
	)

Perform a partial reduction based on an associative binary function, across one or more indices.

The binary function must be associative. (This is not enforced, but the order of operation is undefined.)

Template Parameters

index	an index to be reduced. For example, if the index is 0, the result will have only one row. If the index is 1, the result will have only one column.
indices	Other indices to be reduced. Because the binary function is associative, the order of the indices does not matter.
BinaryFunction	A binary function invocable with two values of type scalar_type_of_t<Arg>. It must be an associative function. Preferably, it should be a constexpr function, and even more preferably, it should be a standard c++ function such as std::plus or std::multiplies.
Arg	The tensor

Returns

A vector or tensor with reduced dimensions.

reduce() [2/2]

template<typename BinaryFunction , typename Arg , std::enable_if_t< internal::has_uniform_patterns< Arg > and std::is_invocable_r< typename scalar_type_of< Arg >::type, BinaryFunction &&, typename scalar_type_of< Arg >::type, typename scalar_type_of< Arg >::type >::value, int > = 0>

constexpr scalar_type_of_t<Arg> OpenKalman::reduce	(	const BinaryFunction &	b,
		const Arg &	arg
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Perform a complete reduction based on an associative binary function, and return a scalar.

The binary function must be associative. (This is not enforced, but the order of operation is undefined.)

Template Parameters

BinaryFunction	A binary function invocable with two values of type scalar_type_of_t<Arg>. It must be an associative function. Preferably, it should be a constexpr function, and even more preferably, it should be a standard c++ function such as std::plus or std::multiplies.
Arg	The tensor

Returns

A scalar representing a complete reduction.

scale() [1/2]

template<typename M , typename S , std::enable_if_t< covariance< M > and stdex::convertible_to< S, typename scalar_type_of< M >::type >, int > = 0>

auto OpenKalman::scale ( M &&  m, const S  s  )

inline

Scale a covariance by a factor.

Equivalent to multiplication by the square of a scalar. For a square root covariance, this is equivalent to multiplication by the scalar.

scale() [2/2]

template<typename M , typename A , std::enable_if_t< covariance< M > and typed_matrix< A > and compares_with< vector_space_descriptor_of_t< A, 0 >::ColumnCoefficients, typename MatrixTraits< std::decay_t< M >>>and(not euclidean_transformed< A >), int > = 0>

auto OpenKalman::scale ( M &&  m, A &&  a  )

inline

Scale a covariance by a matrix.

Template Parameters

M	A covariance.
A	A typed_matrix.

A scaled covariance Arg is A * Arg * adjoint(A). A scaled square root covariance L or U is also scaled accordingly, so that scale(L * adjoint(L)) = A * L * adjoint(L) * adjoint(A) or scale(adjoint(U) * U) = A * adjoint(U) * U * adjoint(A).

set_chip()

template<std::size_t... indices, typename Arg , typename Chip , typename... Ixs, std::enable_if_t< writable< Arg > and indexible< Chip > and(values::index< Ixs > and ...) and(sizeof...(indices)==sizeof...(Ixs)), int > = 0>

constexpr Arg&& OpenKalman::set_chip	(	Arg &&	arg,
		Chip &&	chip,
		Ixs...	ixs
	)

Set a sub-array having rank less than the rank of the input object.

A chip is a special type of "thin" slice of width 1 in one or more dimensions, and otherwise no reduction in extents. For example, the result could be a row vector, a column vector, a matrix (e.g., if the input object is a rank-3 or higher tensor), etc.

Template Parameters

indices

The index or indices of the dimension(s) that have been collapsed to a single dimension. For example, if the input object is a matrix, a value of {0} will result in a row vector and a value of {1} will result in a column vector. If the input object is a rank-3 tensor, a value of {0, 1} will result in a matrix.

Parameters

arg	The indexible object in which the chip is to be set.
chip	The chip to be set. It must be a chip, meaning that the dimension is 1 for each of indices.
is	The index value(s) corresponding to indices, in the same order. The values may be positive std::integral types or a positive std::integral_constant.

Returns

arg as modified

set_slice()

template<typename Arg , typename Block , typename... Begin, std::enable_if_t< writable< Arg > and indexible< Block > and(values::index< Begin > and ...) and(sizeof...(Begin) > = index_count<Arg>::value>

constexpr Arg&& OpenKalman::set_slice	(	Arg &&	arg,
		Block &&	block,
		const Begin &...	begin
	)

Assign an object to a particular slice of a matrix or tensor.

Parameters

arg	The writable object in which the slice is to be assigned.
block	The block to be set.
begin	A tuple specifying, for each index of Arg in order, the beginning values::index.
size	A tuple specifying, for each index of Arg in order, the dimensions of the extracted block.

Returns

A reference to arg as modified.

Todo:

Add a static check that Block has the correct vector space descriptors

solve()

template<bool must_be_unique = false, bool must_be_exact = false, typename A , typename B >

constexpr auto OpenKalman::solve	(	A &&	a,
		B &&	b
	)

Solve the equation AX = B for X, which may or may not be a unique solution.

The interface to the relevant linear algebra library determines what happens if A is not invertible.

Template Parameters

must_be_unique	Determines whether the function throws an exception if the solution X is non-unique (e.g., if the equation is under-determined)
must_be_exact	Determines whether the function throws an exception if it cannot return an exact solution, such as if the equation is over-determined. If false, then the function will return an estimate instead of throwing an exception.
A	The matrix A in the equation AX = B
B	The matrix B in the equation AX = B

Returns

The unique solution X of the equation AX = B. If must_be_unique, then the function can return any valid solution for X. In particular, if must_be_unique, the function has the following behavior:

• If A is a zero, then the result X will also be a zero

split() [1/2]

template<std::size_t... indices, typename Arg , typename... Ds, std::enable_if_t< indexible< Arg > and(coordinates::pattern< Ds > and ...) and(sizeof...(indices) > 0>

auto OpenKalman::split ( Arg &&  arg, Ds &&...  ds  )

inline

Split a matrix or tensor into sub-parts, where the split is the same for every index.

This is an inverse of the concatenate operation. In other words, for all std::size_t i..., j... and indexible a..., and given the function template<std::size_t...i> auto f(auto a) { return get_pattern_collection<i>(a)...}; } ((split<i...>(concatenate<i...>(a...), get_pattern_collection<j>(a)...) == std::tuple{a...}) and ...).

Template Parameters

indices	The indices along which to make the split. E.g., 0 means to split along rows, 1 means to split along columns, {0, 1} means to split diagonally.
Arg	The matrix or tensor to be split.
Ds	A set of coordinates::pattern (the same for for each of indices)

split() [2/2]

template<std::size_t... indices, typename Arg , typename... Ds_tups, std::enable_if_t< indexible< Arg > and(sizeof...(indices) > 0>

auto OpenKalman::split ( Arg &&  arg, const Ds_tups &...  ds_tups  )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Split a matrix or tensor into sub-parts of a size defined independently for each index.

This is an inverse of the concatenate operation. In other words, for all std::size_t i... and indexible a..., and given the function template<std::size_t...i> auto f(auto a) { return std::tuple{get_pattern_collection<i>(a)...}; } split<i...>(concatenate<i...>(a...), f<i...>(a)...) == std::tuple{a...}.

Template Parameters

indices	The indices along which to make the split. E.g., 0 means to split along rows, 1 means to split along columns, {0, 1} means to split diagonally.
Arg	The matrix or tensor to be split.
Ds_tups	A set of tuples of coordinates::pattern objects, each tuple having sizeof...(indices) elements

split_diagonal()

template<typename ... Cs, typename M , std::enable_if_t< covariance< M >, int > = 0>

auto OpenKalman::split_diagonal ( M &&  m )

inline

Split Covariance or SquareRootCovariance diagonally.

Split typed matrix into one or more typed matrices diagonally.

split_horizontal()

template<typename ... Cs, typename M , std::enable_if_t< covariance< M >, int > = 0>

auto OpenKalman::split_horizontal ( M &&  m )

inline

Split Covariance or SquareRootCovariance vertically. Result is a tuple of typed matrices.

Split typed matrix into one or more typed matrices horizontally. Column coefficients must all be Axis.

Split typed matrix into one or more typed matrices horizontally.

split_vertical()

template<typename ... Cs, typename M , std::enable_if_t< covariance< M >, int > = 0>

auto OpenKalman::split_vertical ( M &&  m )

inline

Split Covariance or SquareRootCovariance vertically. Result is a tuple of typed matrices.

Split typed matrix into one or more typed matrices vertically.

SquareRootCovariance()

template<typename M , std::enable_if_t< covariance_nestable< M >, int > = 0>

OpenKalman::SquareRootCovariance ( M &&  ) -> SquareRootCovariance< Dimensions< index_dimension_of_v< M, 0 >>, passable_t< M >>

explicit

Deduce SquareRootCovariance type from a covariance_nestable.

Deduce SquareRootCovariance type from a square typed_matrix_nestable.

Deduce SquareRootCovariance type from a square typed_matrix.

tensor_order()

template<typename T , std::enable_if_t< indexible< T >, int > = 0>

constexpr auto OpenKalman::tensor_order

(

const T &

t

)

Return the tensor order of T (i.e., the number of indices of dimension greater than 1).

If T has any zero-dimensional indices, the tensor order is considered to be 0, based on the theory that a zero-dimensional vector space has 0 as its only element, and 0 is a scalar value. This may be subject to change.

Template Parameters

T	A matrix or array

tile()

template<typename... Ds, typename Block , typename... Blocks, std::enable_if_t<(coordinates::pattern< Ds > and ...) and(indexible< Block > and ... and indexible< Blocks >) and(sizeof...(Ds) > = std::max({index_count<Block>::value, index_count<Blocks>::value...})>

decltype(auto) constexpr OpenKalman::tile	(	const std::tuple< Ds... > &	ds_tuple,
		Block &&	block,
		Blocks &&...	blocks
	)

Create a matrix or tensor by tiling individual blocks.

Template Parameters

Ds	A set of coordinates::pattern for the resulting matrix or tensor.
Block	The first block
Blocks	Subsequent blocks

to_dense_object() [1/3]

template<typename T , data_layout layout = data_layout::none, typename Scalar = scalar_type_of_t<T>, typename Arg , std::enable_if_t< indexible< T > and(layout !=data_layout::stride) and values::number< Scalar > and indexible< Arg >, int > = 0>

decltype(auto) constexpr OpenKalman::to_dense_object

(

Arg &&

arg

)

Convert the argument to a dense, writable matrix of a particular scalar type.

Template Parameters

T	A dummy matrix or array from the relevant library (size, shape, and layout are ignored)
layout	The data_layout of the resulting object. If this is data_layout::none, the interface will decide the layout.
Scalar	The Scalar type of the new matrix, if different than that of Arg

Parameters

arg	The object from which the new matrix is based

to_dense_object() [2/3]

template<data_layout layout, typename Scalar , typename Arg , std::enable_if_t< values::number< Scalar > and indexible< Arg > and(layout !=data_layout::stride), int > = 0>

decltype(auto) constexpr OpenKalman::to_dense_object

(

Arg &&

arg

)

Convert the argument to a dense, writable matrix of a particular scalar type.

Template Parameters

layout	The data_layout of the resulting object. If this is data_layout::none, the interface will decide the layout.
Scalar	The Scalar type of the new matrix, if different than that of Arg

Parameters

arg	The object from which the new matrix is based

to_dense_object() [3/3]

template<data_layout layout = data_layout::none, typename Arg , std::enable_if_t< indexible< Arg > and(layout !=data_layout::stride), int > = 0>

decltype(auto) constexpr OpenKalman::to_dense_object

(

Arg &&

arg

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Convert the argument to a dense, writable matrix with the same scalar type as the argument.

Template Parameters

layout

The data_layout of the resulting object (optional). If this is omitted or data_layout::none, the interface will decide the layout.

Parameters

arg	The object from which the new matrix is based

to_diagonal()

template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>

decltype(auto) constexpr OpenKalman::to_diagonal

(

Arg &&

arg

)

Convert an indexible object into a diagonal matrix.

Returns

A diagonal matrix

Todo:

generalize for higher-rank tensors

to_euclidean()

template<typename Arg , std::enable_if_t< indexible< Arg >, int > = 0>

decltype(auto) constexpr OpenKalman::to_euclidean

(

Arg &&

arg

)

Project the vector space associated with index 0 to a Euclidean space for applying directional statistics.

Template Parameters

Arg	A matrix or tensor.

trace()

template<typename Arg >

decltype(auto) constexpr OpenKalman::trace

(

Arg &&

arg

)

Take the trace of a matrix.

This is a generalized trace that applies to rectangular matrices. If the argument is rectangular, this function returns the trace of the square sub-matrix.

Template Parameters

Arg	The matrix

Todo:

Redefine as a particular tensor contraction.

transpose()

template<std::size_t indexa = 0, std::size_t indexb = 1, typename Arg >

decltype(auto) constexpr OpenKalman::transpose

(

Arg &&

arg

)

Swap any two indices of an indexible_object.

By default, the first two indices are transposed.

unary_operation_in_place()

template<typename Operation , typename Arg , std::enable_if_t< writable< Arg > and detail::n_ary_operator< Operation, index_count_v< Arg >, Arg >, int > = 0>

decltype(auto) constexpr OpenKalman::unary_operation_in_place	(	const Operation &	operation,
		Arg &&	arg
	)

Perform a component-wise, in-place unary operation.

Examples:

• In-place unary operation without indices:

  auto m23 = make_dense_object_from<Eigen::Matrix<double, 3, 2>>(1, 2, 3, 4, 5, 6);
  auto opa = [](auto& arg){return ++arg;};
  std::cout << n_ary_operation(opa, m32) << std::endl;

  Output:

  2, 3,
  4, 5,
  6, 7

• In-place unary operation with indices:

  auto opb = [](auto& arg, std::size_t row, std::size_t col){arg += row + col;};
  std::cout << n_ary_operation(opb, m32) << std::endl;

  Output:

  1, 3,
  4, 6,
  7, 9

  Template Parameters

  Operation	The n-ary operation taking an argument and, optionally, a set of indices. The argument to the operation is a component of Arg and will be assignable as a non-const lvalue reference. The operation may either return the result (as a value or reference) or return void (in which case any changes to the component argument will be treated as an in-place modification).
  Arg	The argument, which must be non-const and writable.

  Returns

  A matrix or array in which each component is the result of calling Operation on corresponding components from each of the arguments, in the order specified.

Variable Documentation

all_fixed_indices_are_euclidean

template<typename T >

constexpr bool OpenKalman::all_fixed_indices_are_euclidean

Initial value:

=

    indexible<T> and (detail::all_fixed_indices_are_euclidean_impl<T>(std::make_index_sequence<index_count_v<T>> {}))

Specifies that every fixed-size index of T is euclidean.

No fixed_size index of T is, e.g., Angle, Polar, Spherical, etc.

cholesky_form

template<typename T >

constexpr bool OpenKalman::cholesky_form = detail::is_cholesky_form<std::decay_t<T>>::value

Specifies that a type has a nested native matrix that is a Cholesky square root.

If this is true, then nested_object_of_t<T> is true.

compares_with_pattern_collection

template<typename T , typename D , auto comp = &stdex::is_eq, applicability a = applicability::permitted>

constexpr bool OpenKalman::compares_with_pattern_collection

Initial value:

=

    indexible<T> and
    coordinates::pattern_collection<D> and
    coordinates::pattern_collection_compares_with<decltype(get_pattern_collection(std::declval<T>())), D, comp, a>

Compares the associated pattern collection of indexible T with pattern_collection D.

Template Parameters

T	An indexible object
D	A pattern_collection

constant_diagonal_object

template<typename T >

constexpr bool OpenKalman::constant_diagonal_object

Initial value:

=

    indexible<T> and
    ((interface::get_constant_defined_for<T> and diagonal_matrix<T>) or
      zero<T> or
      one_dimensional<T>)

Specifies that all diagonal elements of a diagonal object are known at compile time to be the same constant value.

A constant diagonal matrix is also a diagonal_matrix. It is not necessarily square. If T is a rank >2 tensor, every rank-2 slice comprising dimensions 0 and 1 must be constant diagonal matrix. To check if the constant is zero, it is better to use zero, which might catch more cases.

constant_object

template<typename T >

constexpr bool OpenKalman::constant_object

Initial value:

=
    indexible<T> and
    ((interface::get_constant_defined_for<T> and not triangular_matrix<T>) or
      detail::element_type_is_fixed<T>::value or
      zero<T> or
      one_dimensional<T>)

Specifies that all elements of an object are known at compile time to be the same constant value.

To check if the constant is zero, it is better to use zero.

copyable_from

template<typename Dest , typename Source >

constexpr bool OpenKalman::copyable_from

Initial value:

=
    patterns_may_match_with<Dest, Source> and
    detail::is_element_copyable<Dest, Source>::value

Specifies that an indexible object is copyable from another indexible object.

Template Parameters

Dest	The object to be copied to
Source	The object to be copied from

covariance_nestable

template<typename T >

constexpr bool OpenKalman::covariance_nestable

Initial value:

=

    triangular_matrix<T> or hermitian_matrix<T>

T is an acceptable nested matrix for a covariance (including triangular_covariance).

diagonal_matrix

template<typename T >

constexpr bool OpenKalman::diagonal_matrix

Initial value:

=

    triangular_matrix<T, triangle_type::diagonal>

Specifies that a type is a diagonal matrix or tensor.

A diagonal matrix has zero components everywhere except the main diagonal. It is not necessarily square. For rank >2 tensors, every rank-2 slice comprising dimensions 0 and 1 must be diagonal.

dimension_size_of_index_is

template<typename T , std::size_t index, std::size_t value, auto comp = &stdex::is_eq, applicability b = applicability::guaranteed>

constexpr bool OpenKalman::dimension_size_of_index_is

Initial value:

=

    indexible<T> and
    values::size_compares_with<index_dimension_of<T, index>, std::integral_constant<std::size_t, value>, comp, b>

Specifies that a given index of T has a specified size.

If b == applicability::permitted, then the concept will apply if there is a possibility that the specified index of T is value.

Template Parameters

comp	A consteval-callable object taking the comparison result (e.g., std::partial_ordering) and returning a bool value

dynamic_dimension

template<typename T , std::size_t N>

constexpr bool OpenKalman::dynamic_dimension = detail::is_dynamic_dimension<T, N>::value

Specifies that T's index N has a dimension defined at run time.

The matrix library interface will specify this for native matrices and expressions.

euclidean_transformed

template<typename T >

constexpr bool OpenKalman::euclidean_transformed

Initial value:

=

    euclidean_mean<T> and (not has_untyped_index<T, 0>)

Specifies that T is a Euclidean mean that actually has coefficients that are transformed to Euclidean space.

has_dynamic_dimensions

template<typename T >

constexpr bool OpenKalman::has_dynamic_dimensions

Initial value:

=

    (dynamic_index_count_v<T> == stdex::dynamic_extent) or (dynamic_index_count_v<T> > 0)

Specifies that T has at least one index with dynamic dimensions.

has_nested_object

template<typename T >

constexpr bool OpenKalman::has_nested_object

Initial value:

=

    interface::nested_object_defined_for<T>

A matrix that has a nested matrix, if it is a wrapper type.

has_untyped_index

template<typename T , std::size_t N>

constexpr bool OpenKalman::has_untyped_index

Initial value:

=

    coordinates::euclidean_pattern<decltype(get_pattern_collection(std::declval<T>(), std::integral_constant<std::size_t, N>{}))>

Specifies that T has an untyped index N.

Index N of T is Euclidean and non-modular (e.g., Axis, Dimensions<2>, etc.).

hermitian_adapter

template<typename T , HermitianAdapterType t = HermitianAdapterType::any>

constexpr bool OpenKalman::hermitian_adapter = hermitian_matrix<T> and detail::hermitian_adapter_impl<std::decay_t<T>, t>::value

Specifies that a type is a hermitian matrix adapter of a particular type.

A hermitian adapter may or may not actually be a hermitian_matrix, depending on whether it is a square_shaped. If it is not a square matrix, it can still be a hermitian adapter, but only the truncated square portion of the matrix would be hermitian.

Template Parameters

T	A matrix or tensor.
t	The HermitianAdapterType of T.

hermitian_adapter_type_of_v

template<typename T , typename... Ts>

constexpr auto OpenKalman::hermitian_adapter_type_of_v = hermitian_adapter_type_of<T, Ts...>::value

The triangle_type associated with the storage triangle of a hermitian_matrix.

Possible values are lower, upper, or any.

hermitian_matrix

template<typename T >

constexpr bool OpenKalman::hermitian_matrix

Initial value:

=
    square_shaped<T> and
    (detail::is_explicitly_hermitian<T>::value or
      ((constant_object<T> or diagonal_matrix<T>) and detail::is_inferred_hermitian_matrix<T>::value))

Specifies that a type is a hermitian matrix.

For rank >2 tensors, this must be applicable on every rank-2 slice comprising dimensions 0 and 1.

identity_matrix

template<typename T >

constexpr bool OpenKalman::identity_matrix

Initial value:

=
      detail::is_identity_matrix<T>::value

Specifies that a type is known at compile time to be a rank-2 or lower identity matrix.

This is a generalized identity matrix which may be rectangular (with zeros in all non-diagonal components. A 1D vector with constant element 1 and an empty_matrix are also considered to be identity matrices.

index_collection_for

template<typename Indices , typename T >

constexpr bool OpenKalman::index_collection_for

Initial value:

=
    collections::index<Indices> and
    indexible<T> and
    (not values::size_compares_with<collections::size_of<Indices>, index_count<T>, &stdex::is_lt>) and
    detail::index_collection_for_impl<Indices, T>::value

Indices is a collection of indices that are compatible with indexible object T.

This performs static bounds checking.

indexible

template<typename T >

constexpr bool OpenKalman::indexible

Initial value:

=

    interface::object_traits<stdex::remove_cvref_t<T>>::is_specialized

T is a multidimensional array type.

T can be a vector, matrix, tensor, or other generalized array in which elements are accessed by a set of indices. It includes any type for which interface::object_traits is specialized.

linearized_function

template<typename T , std::size_t order = 1>

constexpr bool OpenKalman::linearized_function

Initial value:

=

    oin::is_linearized_function<std::decay_t<T>, order>::value

A linearized function (with defined Jacobian and optionally Hessian functions).

If order == 1, then the Jacobian is defined. If order == 2, then the Hessian is defined.

Template Parameters

T	The function.
order	The maximum order in which T's Taylor series is defined.

one_dimensional

template<typename T , applicability b = applicability::guaranteed>

constexpr bool OpenKalman::one_dimensional

inline

Initial value:

=

    indexible<T> and
    detail::one_dimensional_impl<T, b>()

Specifies that a type is one-dimensional in every index.

Each index also must have an equivalent coordinates::pattern object.

pattern_collection_for

template<typename P , typename T , applicability a = applicability::permitted>

constexpr bool OpenKalman::pattern_collection_for = detail::compatible_shape_with_impl_cpp17<P, T, a>::value

pattern collection P is compatible with indexible T.

If one or the other is dynamic, both must be dynamic, otherwise, the static dimensions must match. Any trailing patterns in P must be equivalent to Dimensions<1>.

Template Parameters

P	a coordinates::pattern_collection
T	an indexible object

patterns_match_with

template<typename... Ts>

constexpr bool OpenKalman::patterns_match_with

Initial value:

=
    (indexible<Ts> and ...) and
    detail::pattern_mchx<void, Ts...>::value

Specifies that a set of indexible objects have equivalent vector space descriptors for each index.

Template Parameters

Ts	A set of indexible objects

See also

patterns_may_match_with

patterns_match

patterns_may_match_with

template<typename... Ts>

constexpr bool OpenKalman::patterns_may_match_with

Initial value:

=
    (indexible<Ts> and ...) and
    detail::pattern_mch<void, Ts...>::value

Specifies that indexible objects Ts may have equivalent dimensions and vector-space types.

Two dimensions are considered the same if their coordinates::pattern are equivalent.

See also

patterns_match_with

patterns_match

square_shaped

template<typename T , applicability b = applicability::guaranteed>

constexpr bool OpenKalman::square_shaped

Initial value:

=
    indexible<T> and
    (interface::is_square_defined_for<T, b> ?
      detail::is_explicitly_square<T, b>::value :
      detail::square_shaped_impl<T, b>())

Specifies that an object is square (i.e., has equivalent coordinates::pattern along each dimension).

Any trailing 1D Euclidean descriptors are disregarded. A vector must be one-dimensional. A 0-by-0 matrix or tensor is considered to be square.

Template Parameters

b	Defines what happens when one or more of the indices has dynamic dimension: if b == applicability::guaranteed: T is known at compile time to be square; if b == applicability::permitted: It is known at compile time that T may be square.

transformation_input

template<typename T , typename Coeffs = typename oin::PerturbationTraits<T>::RowCoefficients>

constexpr bool OpenKalman::transformation_input

Initial value:

=

    typed_matrix<T> and vector<T> and has_untyped_index<T, 1> and (not euclidean_transformed<T>) and
    coordinates::compares_with<typename oin::PerturbationTraits<T>::RowCoefficients, Coeffs>

T is an acceptable input to a tests.

Template Parameters

Coeffs

The expected coefficients of the tests input.

triangular_adapter

template<typename T >

constexpr bool OpenKalman::triangular_adapter

Initial value:

=
    detail::is_triangular_adapter<T>::value and has_nested_object<T> and
    has_nested_object<T>

Specifies that a type is a triangular adapter of triangle type tri.

A triangular adapter takes a matrix and presents a view in which, in one or both triangular (or trapezoidal) sides on either side of the diagonal are zero. The matrix need not be square.

Template Parameters

T	A matrix or tensor.

triangular_matrix

template<typename T , triangle_type t = triangle_type::any>

constexpr bool OpenKalman::triangular_matrix

Initial value:

=

    indexible<T> and
    (t == triangle_type_of_v<T> or
      (t == triangle_type::any and triangle_type_of_v<T> != triangle_type::none) or
      ((t == triangle_type::upper or t == triangle_type::lower) and triangle_type_of_v<T> == triangle_type::diagonal))

Specifies that an argument is an indexible object having a given triangle_type (e.g., upper, lower, or diagonal).

This can also test whether the argument is triangular (triangle_type::none). To test whether the argument has any triangle type, use triangle_type::any (which is the default). Diagonal matrices are considered to also be both upper and lower.

Template Parameters

t	The triangle_type

typed_adapter

template<typename T >

constexpr bool OpenKalman::typed_adapter

Initial value:

=

    typed_matrix<T> or covariance<T> or euclidean_expr<T>

Specifies that T is a typed adapter expression.

typed_matrix_nestable

template<typename T >

constexpr bool OpenKalman::typed_matrix_nestable

Initial value:

=

    indexible<T>

Specifies a type that is nestable in a general typed matrix (e.g., matrix, mean, or euclidean_mean)

untyped_adapter

template<typename T >

constexpr bool OpenKalman::untyped_adapter

Initial value:

=

    internal::diagonal_expr<T> or internal::hermitian_expr<T> or internal::triangular_expr<T>

Specifies that T is an untyped adapter expression.

Untyped adapter expressions are generally used whenever the native matrix library does not have an important built-in matrix type, such as a diagonal matrix, a triangular matrix, or a hermitian matrix.

vector

template<typename T , std::size_t N = 0, applicability b = applicability::guaranteed>

constexpr bool OpenKalman::vector

Initial value:

=

    indexible<T> and
    detail::vector_impl<T, N, b>()

T is a vector (e.g., column or row vector).

In this context, a vector is an object in which every index but one is 1D.

Template Parameters

T	An indexible object
N	An index designating the "large" index (e.g., 0 for a column vector, 1 for a row vector)
b	Whether the vector status is guaranteed known at compile time (applicability::guaranteed), or only known at runtime (applicability::permitted)

See also

is_vector

wrappable

template<typename T >

constexpr bool OpenKalman::wrappable = detail::is_wrappable<T>::value

Specifies that every fixed-size index of T (other than potentially index 0) is euclidean.

This indicates that T is suitable for wrapping along index 0.

See also

get_wrappable

wrapped_mean

template<typename T >

constexpr bool OpenKalman::wrapped_mean

Initial value:

=

    mean<T> and (not has_untyped_index<T, 0>)

Specifies that T is a wrapped mean (i.e., its row fixed_pattern have at least one type that requires wrapping).

zero

template<typename T , unsigned int epsilon_factor = 0>

constexpr bool OpenKalman::zero

Initial value:

=
    detail::is_zero_constant<T, epsilon_factor>::value or
    detail::constant_element_is_0_ep<T, epsilon_factor>::value

Specifies that a type is known at compile time to be a constant matrix of value zero.

Template Parameters

epsilon_factor

An epsilon value to account for rounding error. This is multiplied by std::numeric_limits<std::decay_t<T::epsilon(), if it exists. If it is zero, the match must be exact.