The namespace for features relating to patterns::pattern object. More...

Namespaces
	angle
	Namespace for definitions relating to specialized instances of Angle.

	inclination
	Namespace for definitions relating to specialized instances of Inclination.

	views
	The namespace for views for patterns::pattern object.

Classes
struct	Angle
	An angle or any other simple modular value. More...

struct	Any

struct	common_descriptor_type
	The common type within a pattern, if it exists. More...

struct	common_descriptor_type< T, std::enable_if_t< descriptor< T > > >

struct	common_descriptor_type< T, std::enable_if_t< descriptor_collection< T > > >

struct	dimension_of
	The size of a patterns::pattern. More...

struct	dimension_of< T, std::void_t< decltype(get_dimension(std::declval< T >()))> >

struct	Dimensions
	A structure representing the dimensions associated with of a particular index. More...

struct	Dimensions< stdex::dynamic_extent >
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

struct	dimensions_tuple_view
	A view to the dimensions of a uniformly_gettable pattern_collection. More...

struct	Distance
	A non-negative real or integral number, [0,∞], representing a distance. More...

struct	Inclination
	A non-negative real number φ representing an inclination (angle from the positive z axis). More...

struct	pattern_collection_element
	The type of the element at a given index, if it can be determined at compile time. More...

struct	pattern_collection_element< i, T, std::enable_if_t< pattern_collection< 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	Polar
	An atomic patterns::descriptor reflecting polar coordinates. More...

struct	Spherical
	A patterns::descriptor reflecting spherical coordinates according to the ISO 80000-2:2019 convention. More...

struct	stat_dimension_of
	The dimension size of a set of patterns::pattern if it is transformed into Euclidean space. More...

struct	stat_dimension_of< T, std::enable_if_t< values::index< decltype(patterns::get_stat_dimension(std::declval< T >()))> > >

struct	transpose_view
	A view representing a transpose of a pattern_collection. More...

struct	uniform_pattern_type
	If T is a uniform_pattern, `type` is an alias for the uniform component. More...

struct	uniform_pattern_type< T, std::enable_if_t< pattern< T > and(euclidean_pattern< T > or detail::common_descriptor_dimension_is_1< T >::value)> >

Typedefs
using	Axis = Dimensions< 1 >
	Alias for a 1D Euclidean patterns::pattern object.

template<typename T >
using	common_descriptor_type_t = typename common_descriptor_type< T >::type
	Helper template for common_descriptor_type.

template<std::size_t i, typename T >
using	pattern_collection_element_t = typename pattern_collection_element< i, T >::type
	Helper template for collection_element.

template<typename T >
using	uniform_pattern_type_t = typename uniform_pattern_type< T >::type
	Helper template for uniform_pattern_type.

Functions
template<typename D , std::enable_if_t< fixed_pattern< D > and euclidean_pattern< D >, int > = 0>
	Dimensions (D &&) -> Dimensions< dimension_of< D >::value >

	Dimensions (const std::size_t &) -> Dimensions< stdex::dynamic_extent >

template<auto comp = &stdex::is_eq, typename A , typename B , std::enable_if_t< pattern< A > and pattern< B > and std::is_invocable_r_v< bool, decltype(comp), stdex::partial_ordering >, int > = 0>
constexpr auto	compare (const A &a, const B &b)
	Compare two patterns::pattern objects lexicographically. More...

template<auto comp = &stdex::is_eq, std::size_t N = values::unbounded_size, typename T , typename D , std::enable_if_t<(N==values::unbounded_size or N > 0>
constexpr auto	compare_collection_patterns_with_dimension (const T &t, const D &d)
	Compares the dimensions of the first N elements of a pattern_collection with a particular value. More...

template<std::size_t dim, auto comp = &stdex::is_eq, std::size_t N = values::unbounded_size, typename T , std::enable_if_t<(N==values::unbounded_size or N > 0>
constexpr auto	compare_collection_patterns_with_dimension (const 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<auto comp = &stdex::is_eq, typename A , typename B , std::enable_if_t< pattern_collection< A > and pattern_collection< B > and std::is_invocable_r_v< bool, decltype(comp), stdex::partial_ordering >, int > = 0>
constexpr auto	compare_pattern_collections (const A &a, const B &b)
	Compare each element of two pattern_collection objects lexicographically. More...

template<typename A , typename B , typename Comparison = stdex::compare_three_way, std::enable_if_t< pattern< A > and pattern< B > and std::is_invocable_r< stdex::partial_ordering, Comparison, std::size_t, std::size_t >::value, int > = 0>
constexpr auto	compare_three_way (A &&a, B &&b, const Comparison &c={})
	Compare two patterns::pattern objects lexicographically. More...

template<typename T , typename R , std::enable_if_t< descriptor< T > and collections::collection< R >, int > = 0>
decltype(auto) constexpr	from_stat_space (const T &t, R &&stat_data_view)
	Maps a range in a vector space for directional-statistics back to a range reflecting vector-space data. More...

template<std::size_t N = values::unbounded_size, typename T , std::enable_if_t<(N==values::unbounded_size or N > 0>
constexpr auto	get_common_pattern_collection_dimension (const T &t)
	Queries whether the first N elements of a pattern_collection have the same dimensions. More...

template<typename Arg , std::enable_if_t< sized_pattern< Arg >, int > = 0>
constexpr auto	get_dimension (const Arg &arg)
	Get the vector dimension of patterns::pattern Arg.

template<typename Arg , std::enable_if_t< pattern< Arg > and(descriptor< Arg > or collections::sized< Arg > or detail::is_unbound_fixed_range< Arg >::value), int > = 0>
constexpr auto	get_is_euclidean (const Arg &arg)
	Determine, whether patterns::pattern Arg is euclidean.

template<typename P , typename I , std::enable_if_t< pattern_collection< P > and values::index< I >, int > = 0>
decltype(auto) constexpr	get_pattern (P &&p, I i)
	Get a pattern within a pattern_collection. More...

template<std::size_t i, typename P , std::enable_if_t< pattern_collection< P >, int > = 0>
decltype(auto) constexpr	get_pattern (P &&p)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename Arg , std::enable_if_t< descriptor< Arg > or(descriptor_collection< Arg > and(collections::sized< Arg > or detail::range_value_has_fixed_stat_dimension< Arg >::value)), int > = 0>
constexpr auto	get_stat_dimension (const Arg &arg)
	Get the vector dimension of patterns::pattern Arg when transformed into statistical space. More...

template<typename T , std::enable_if_t< pattern< T >, int > = 0>
constexpr auto	get_uniform_pattern_component (T &&t)
	If the argument is a uniform pattern, return the 1D component that can be replicated to produce the argument. More...

template<typename A , typename B , std::enable_if_t< pattern< A > and pattern< B >, int > = 0>
constexpr auto	is_uniform_pattern_component_of (const A &a, const B &b)

template<typename... Args, std::enable_if_t<(... and descriptor< Args >), int > = 0>
constexpr auto	make_descriptor_range (Args &&...args)
	Make a descriptor_collection from a list of descriptors. More...

template<std::size_t rank, typename P , std::enable_if_t< pattern_collection< P > and values::fixed_value_compares_with< collections::size_of< P >, stdex::dynamic_extent, &stdex::is_neq >, int > = 0>
constexpr auto	to_extents (P &&p)
	Convert a pattern_collection to std::extents. More...

template<std::size_t rank, typename IndexType , std::size_t... Extents>
decltype(auto) constexpr	to_extents (const stdex::extents< IndexType, Extents... > &p)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<std::size_t rank, typename IndexType , std::size_t... Extents>
constexpr auto	to_extents (stdex::extents< IndexType, Extents... > &&p)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename P , std::enable_if_t< pattern_collection< P > and values::fixed_value_compares_with< collections::size_of< P >, stdex::dynamic_extent, &stdex::is_neq >, int > = 0>
constexpr auto	to_extents (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 T , typename R , std::enable_if_t< descriptor< T > and collections::collection< R >, int > = 0>
decltype(auto) constexpr	to_stat_space (const T &t, R &&data_view)
	Maps a range reflecting vector-space data to a corresponding range in a vector space for directional statistics. More...

template<typename T , typename R , std::enable_if_t< descriptor< T > and collections::collection< R >, int > = 0>
decltype(auto) constexpr	wrap (const T &t, R &&data_view)
	wraps a range reflecting vector-space data to its primary range. More...

template<typename P >
	transpose_view (P &&) -> transpose_view< P >
	Deduction guides.

Variables
template<typename T , typename U , auto comp = &stdex::is_eq, applicability a = applicability::guaranteed>
constexpr bool	collection_compares_with
	Compares two pattern_collection objects. More...

template<typename T , std::size_t dim, auto comp = &stdex::is_eq, std::size_t N = values::unbounded_size, applicability b = applicability::guaranteed>
constexpr bool	collection_patterns_compare_with_dimension
	Specifies that each element of a pattern_collection T has dimension dim for the first N indices. More...

template<typename T , std::size_t N = values::unbounded_size, applicability b = applicability::guaranteed>
constexpr bool	collection_patterns_have_same_dimension
	Specifies that the first N elements of a pattern_collection have the same dimensions. More...

template<typename T , typename U , auto comp = &stdex::is_eq, applicability a = applicability::guaranteed>
constexpr bool	compares_with
	Compares two patterns::pattern objects. More...

template<typename T >
constexpr bool	descriptor
	T is an atomic (non-separable or non-composite) grouping of patterns::pattern objects. More...

template<typename T >
constexpr bool	descriptor_collection
	An object describing a collection of /ref patterns::descriptor objects. More...

template<typename T >
constexpr bool	dynamic_pattern
	A patterns::pattern for which the size is defined at runtime. More...

template<typename T >
constexpr bool	euclidean_pattern = detail::euclidean_pattern_impl<T>::value
	A patterns::pattern for a normal Euclidean vector.

template<typename T >
constexpr bool	euclidean_pattern_collection
	An object describing a collection of /ref euclidean_pattern objects. More...

template<typename T >
constexpr bool	fixed_pattern
	A patterns::pattern for which the dimension is fixed at compile time. More...

template<typename T >
constexpr bool	fixed_pattern_collection
	An object describing a fixed-size collection of /ref fixed_pattern objects. More...

template<typename T >
constexpr bool	pattern
	An object describing the characteristics (e.g., dimensions, wrapping structure) of an index. More...

template<typename T >
constexpr bool	pattern_collection
	An object describing a sized collection of /ref sized_pattern objects. More...

template<typename T >
constexpr bool	sized_pattern
	An object describing the set of coordinates associated with a tensor index. More...

template<typename T , applicability a = applicability::guaranteed>
constexpr bool	uniform_pattern
	T is a patterns::pattern that is either empty or can be decomposed into a uniform set of 1D patterns::pattern. More...

template<typename T >
constexpr auto	dimension_of_v = dimension_of<T>::value
	Helper template for patterns::dimension_of.

template<typename T >
constexpr auto	stat_dimension_of_v = stat_dimension_of<T>::value
	Helper template for patterns::stat_dimension_of.

Detailed Description

The namespace for features relating to patterns::pattern object.

Function Documentation

◆ compare()

template<auto comp = &stdex::is_eq, typename A , typename B , std::enable_if_t< pattern< A > and pattern and std::is_invocable_r_v< bool, decltype(comp), stdex::partial_ordering >, int > = 0>

constexpr auto OpenKalman::patterns::compare	(	const A &	a,
		const B &	b
	)

Compare two patterns::pattern objects lexicographically.

Consecutive euclidean_pattern arguments are consolidated before the comparison occurs.

Template Parameters

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

◆ compare_collection_patterns_with_dimension()

template<auto comp = &stdex::is_eq, std::size_t N = values::unbounded_size, typename T , typename D , std::enable_if_t<(N==values::unbounded_size or N > 0>

constexpr auto OpenKalman::patterns::compare_collection_patterns_with_dimension	(	const T &	t,
		const D &	d
	)

Compares the dimensions of the first N elements of a pattern_collection with a particular value.

If N exceeds the size of T, T will effectively be padded with Dimensions<1>. If N == values::unbounded_size, all elements will be compared.

Template Parameters

N	Either values::unbounded_size or an integer greater than 0.

◆ compare_pattern_collections()

template<auto comp = &stdex::is_eq, typename A , typename B , std::enable_if_t< pattern_collection< A > and pattern_collection and std::is_invocable_r_v< bool, decltype(comp), stdex::partial_ordering >, int > = 0>

constexpr auto OpenKalman::patterns::compare_pattern_collections	(	const A &	a,
		const B &	b
	)

Compare each element of two pattern_collection objects lexicographically.

Performs a compare operation on each element of the collection. If the patterns are different sizes, trailing Dimensions<1> patterns are added to the smaller one before the comparison.

Template Parameters

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

◆ compare_three_way()

template<typename A , typename B , typename Comparison = stdex::compare_three_way, std::enable_if_t< pattern< A > and pattern and std::is_invocable_r< stdex::partial_ordering, Comparison, std::size_t, std::size_t >::value, int > = 0>

constexpr auto OpenKalman::patterns::compare_three_way	(	A &&	a,
		B &&	b,
		const Comparison &	c = `{}`
	)

Compare two patterns::pattern objects lexicographically.

Consecutive euclidean_pattern arguments are consolidated before the comparison occurs.

Template Parameters

Comparison A callable comparison function compatible with std::partial_ordering, such as std::compare_three_way

◆ from_stat_space()

template<typename T , typename R , std::enable_if_t< descriptor< T > and collections::collection< R >, int > = 0>

decltype(auto) constexpr OpenKalman::patterns::from_stat_space	(	const T &	t,
		R &&	stat_data_view
	)

Maps a range in a vector space for directional-statistics back to a range reflecting vector-space data.

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

This is the inverse of to_stat_space.

Parameters

t	A descriptor.
stat_data_view	A range within a data object corresponding to descriptor t.

Maps a range in a vector space for directional-statistics back to a range reflecting vector-space data.

This is the inverse of to_stat_space.

Parameters

t	A descriptor_collection.
stat_data_view	A range within a data object corresponding to patterns::descriptor_collection "descriptor_collection" t

◆ get_common_pattern_collection_dimension()

template<std::size_t N = values::unbounded_size, typename T , std::enable_if_t<(N==values::unbounded_size or N > 0>

constexpr auto OpenKalman::patterns::get_common_pattern_collection_dimension ( const T & t )

Queries whether the first N elements of a pattern_collection have the same dimensions.

If N exceeds the size of T, T will be padded with Dimensions<1>. If N == values::unbounded_size, all elements will be compared. Note that the result will always be true if the number of compared elements is 1.

Template Parameters

N	Either values::unbounded_size or an integer greater than 0.

Returns: a std::optional containing the common dimension, if it exists.

◆ get_pattern()

template<typename P , typename I , std::enable_if_t< pattern_collection and values::index, int > = 0>

decltype(auto) constexpr OpenKalman::patterns::get_pattern	(	P &&	p,
		I	i
	)

Get a pattern within a pattern_collection.

If index i is greater than the size of argument p, the function will return Dimensions<1> or 1.

◆ get_stat_dimension()

template<typename Arg , std::enable_if_t< descriptor< Arg > or(descriptor_collection< Arg > and(collections::sized< Arg > or detail::range_value_has_fixed_stat_dimension< Arg >::value)), int > = 0>

constexpr auto OpenKalman::patterns::get_stat_dimension ( const Arg & arg )

Get the vector dimension of patterns::pattern Arg when transformed into statistical space.

This is the dimension of a vector corresponding to Arg that has been transformed to Euclidan space for directional statistics.

◆ get_uniform_pattern_component()

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

constexpr auto OpenKalman::patterns::get_uniform_pattern_component ( T && t )

If the argument is a uniform pattern, return the 1D component that can be replicated to produce the argument.

The result will equal the argument if replicated some number of times (including zero times).

Returns: An std::optional object containing the 1D component, if it exists.

◆ make_descriptor_range()

template<typename... Args, std::enable_if_t<(... and descriptor< Args >), int > = 0>

constexpr auto OpenKalman::patterns::make_descriptor_range ( Args &&... args )

Make a descriptor_collection from a list of descriptors.

The result will be a std::ranges::random_access_range<T>. To create a tuple-like structure instead, you should construct a std::tuple.

◆ to_extents() [1/2]

template<std::size_t rank, typename P , std::enable_if_t< pattern_collection and values::fixed_value_compares_with< collections::size_of, stdex::dynamic_extent, &stdex::is_neq >, int > = 0>

constexpr auto OpenKalman::patterns::to_extents ( P && p )

Convert a pattern_collection to std::extents.

Template Parameters

rank	The rank of the result. The rank must be large enough to hold all non-unitary extents. If necessary, the template parameters of the result will be padded with sufficient trailing 1 values to meet this rank.

◆ to_extents() [2/2]

template<typename P , std::enable_if_t< pattern_collection and values::fixed_value_compares_with< collections::size_of, stdex::dynamic_extent, &stdex::is_neq >, int > = 0>

constexpr auto OpenKalman::patterns::to_extents ( P && p )

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

Derive the rank from the argument. The number of extents will be minimized.

◆ to_stat_space()

template<typename T , typename R , std::enable_if_t< descriptor< T > and collections::collection< R >, int > = 0>

decltype(auto) constexpr OpenKalman::patterns::to_stat_space	(	const T &	t,
		R &&	data_view
	)

Maps a range reflecting vector-space data to a corresponding range in a vector space for directional statistics.

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

This is the inverse of from_stat_space.

Parameters

t	A descriptor.
data_view	A range within a data object corresponding to descriptor t.

Maps a range reflecting vector-space data to a corresponding range in a vector space for directional statistics.

This is the inverse of from_stat_space.

Parameters

t	A descriptor_collection.
data_view	A range within a data object corresponding to descriptor_collection t

◆ wrap()

template<typename T , typename R , std::enable_if_t< descriptor< T > and collections::collection< R >, int > = 0>

decltype(auto) constexpr OpenKalman::patterns::wrap	(	const T &	t,
		R &&	data_view
	)

wraps a range reflecting vector-space data to its primary range.

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

The wrapping operation is equivalent to mapping from modular space to Euclidean space and then back again, or in other words, performing to_stat_space followed by from_stat_space.

Parameters


  
    t A descriptor. 
    data_view A range within a data object corresponding to descriptor t.

wraps a range reflecting vector-space data to its primary range.

The wrapping operation is equivalent to mapping from modular space to Euclidean space and then back again, or in other words, performing to_stat_space followed by from_stat_space.

Parameters


  
    t A descriptor_collection. 
    data_view A range within a data object corresponding to descriptor_collection t.

Variable Documentation

◆ collection_compares_with

template<typename T , typename U , auto comp = &stdex::is_eq, applicability a = applicability::guaranteed>

constexpr bool OpenKalman::patterns::collection_compares_with

Initial value:

=
    pattern_collection<T> and pattern_collection<U> and
    std::is_invocable_r_v<bool, decltype(comp), stdex::partial_ordering> and
    detail::collection_compares_with_impl<T, U, comp, a>()

Compares two pattern_collection objects.

Corresponding patterns in each argument are compared. Trailing 1D patterns are ignored.

Template Parameters

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

◆ collection_patterns_compare_with_dimension

template<typename T , std::size_t dim, auto comp = &stdex::is_eq, std::size_t N = values::unbounded_size, applicability b = applicability::guaranteed>

constexpr bool OpenKalman::patterns::collection_patterns_compare_with_dimension

inline

Initial value:

=
    (N == values::unbounded_size or N > 0) and
    pattern_collection<T> and
    detail::collection_patterns_compare_with_dimension_impl<T, dim, comp, N, b>()

Specifies that each element of a pattern_collection T has dimension dim for the first N indices.

If N is greater than the size of T, T will effectively be padded with Dimensions<1>.

Template Parameters

N	Either values::unbounded_size or an integer greater than 0.

◆ collection_patterns_have_same_dimension

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

constexpr bool OpenKalman::patterns::collection_patterns_have_same_dimension

inline

Initial value:

=
    (N == values::unbounded_size or N > 0) and
    pattern_collection<T> and
    detail::collection_patterns_have_same_dimension_impl<T, N, b>()

Specifies that the first N elements of a pattern_collection have the same dimensions.

If N exceeds the size of T, T will be padded with Dimensions<1>. If N == values::unbounded_size, all elements will be compared. Note that the result will always be true if the number of compared elements is 1.

Template Parameters

N	Either values::unbounded_size or an integer greater than 0.

◆ compares_with

template<typename T , typename U , auto comp = &stdex::is_eq, applicability a = applicability::guaranteed>

constexpr bool OpenKalman::patterns::compares_with

Initial value:

=
    pattern<T> and pattern<U> and
    std::is_invocable_r_v<bool, decltype(comp), stdex::partial_ordering> and
    detail::compares_with_impl<T, U, comp, a>()

Compares two patterns::pattern objects.

Every pattern in the set must be potentially comparable to every other respective pattern in the set. Sets of patterns are equivalent if they are treated functionally the same.

Any pattern is equivalent to itself.
std::tuple<As...> is equivalent to std::tuple<Bs...>, if each As is equivalent to its respective Bs.
std::tuple<A> is equivalent to A, and vice versa.
Dynamic patterns::euclidean_pattern objects are equivalent to any other patterns::euclidean_pattern,
Examples:
compares_with<std::tuple<Axis, Direction>, std::tuple<Axis, Direction>> compares_with<std::tuple<Axis, Direction>, std::tuple<Axis, Direction, angle::Radians>, less_than<>, applicability::guaranteed> compares_with<std::tuple<Axis, Direction>, std::tuple<Dimensions<>, Direction, angle::Radians>, less_than<>, applicability::permitted>

Template Parameters

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

◆ descriptor

template<typename T >

constexpr bool OpenKalman::patterns::descriptor

Initial value:

=
    interface::pattern_descriptor_traits<std::decay_t<stdex::unwrap_ref_decay_t<T>>>::is_specialized or
    values::index<T>

T is an atomic (non-separable or non-composite) grouping of patterns::pattern objects.

◆ descriptor_collection

template<typename T >

constexpr bool OpenKalman::patterns::descriptor_collection

Initial value:

=
    detail::descriptor_range<T> or
    detail::descriptor_tuple<T>

An object describing a collection of /ref patterns::descriptor objects.

This can be either a uniformly_gettable structure or a sized std::ranges::random_access_range.

◆ dynamic_pattern

template<typename T >

constexpr bool OpenKalman::patterns::dynamic_pattern

inline

Initial value:

=
    pattern<T> and (not fixed_pattern<T>)

A patterns::pattern for which the size is defined at runtime.

◆ euclidean_pattern_collection

template<typename T >

constexpr bool OpenKalman::patterns::euclidean_pattern_collection

Initial value:

=
    collections::collection<T> and
    ( detail::is_euclidean_pattern_iter<T>::value or
      detail::is_euclidean_descriptor_range<T>::value)

An object describing a collection of /ref euclidean_pattern objects.

◆ fixed_pattern

template<typename T >

constexpr bool OpenKalman::patterns::fixed_pattern

Initial value:

=
    sized_pattern<T> and
    values::fixed_value_compares_with<dimension_of<T>, stdex::dynamic_extent, &stdex::is_neq>

A patterns::pattern for which the dimension is fixed at compile time.

◆ fixed_pattern_collection

template<typename T >

constexpr bool OpenKalman::patterns::fixed_pattern_collection

Initial value:

=
    collections::collection<T> and
    values::fixed_value_compares_with<collections::size_of<T>, stdex::dynamic_extent, &stdex::is_neq> and
    ( detail::is_fixed_pattern_iter<T>::value or
      detail::is_fixed_descriptor_range<T>::value)

An object describing a fixed-size collection of /ref fixed_pattern objects.

◆ pattern

template<typename T >

constexpr bool OpenKalman::patterns::pattern

inline

Initial value:

=
    descriptor<T> or descriptor_collection<T>

An object describing the characteristics (e.g., dimensions, wrapping structure) of an index.

◆ pattern_collection

template<typename T >

constexpr bool OpenKalman::patterns::pattern_collection

Initial value:

=
    collections::collection<T> and
    ( ( stdex::ranges::random_access_range<T> and
        detail::is_pattern_range<T>::value) or
      detail::is_pattern_iter<T>::value
    )

An object describing a sized collection of /ref sized_pattern objects.

◆ sized_pattern

template<typename T >

constexpr bool OpenKalman::patterns::sized_pattern

inline

Initial value:

=
    descriptor<T> or (collections::sized<T> and descriptor_collection<T>)

An object describing the set of coordinates associated with a tensor index.

◆ uniform_pattern

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

constexpr bool OpenKalman::patterns::uniform_pattern

Initial value:

=
    (a == applicability::guaranteed and detail::is_uniform_pattern_impl<T>::value) or
    (a == applicability::permitted and not detail::heterogeneous_pattern<T>::value)

T is a patterns::pattern that is either empty or can be decomposed into a uniform set of 1D patterns::pattern.

If T is a uniform pattern, uniform_pattern_type<T>::type will exist and will be one-dimensional.

Namespaces

Classes

Typedefs

Functions

Variables

Detailed Description

Function Documentation

◆ compare()

◆ compare_collection_patterns_with_dimension()

◆ compare_pattern_collections()

◆ compare_three_way()

◆ from_stat_space()

◆ get_common_pattern_collection_dimension()

◆ get_pattern()

◆ get_stat_dimension()

◆ get_uniform_pattern_component()

◆ make_descriptor_range()

◆ to_extents() [1/2]

◆ to_extents() [2/2]

◆ to_stat_space()

◆ wrap()

Variable Documentation

◆ collection_compares_with

◆ collection_patterns_compare_with_dimension

◆ collection_patterns_have_same_dimension

◆ compares_with

◆ descriptor

◆ descriptor_collection

◆ dynamic_pattern

◆ euclidean_pattern_collection

◆ fixed_pattern

◆ fixed_pattern_collection

◆ pattern

◆ pattern_collection

◆ sized_pattern

◆ uniform_pattern