Classes
class	mundy::AVector< T, N, Accessor >
	Class for an Nx1 vector with scalar-like entries. More...
struct	Kokkos::reduction_identity< mundy::Vector< T, N > >
	The identity of Kokkos::Sum over mundy::Vector, so Vector-valued sums work in any Kokkos::parallel_reduce. More...

Namespaces
namespace	mundy

Concepts
concept	mundy::ValidVectorType
	A temporary concept to check if a type is a valid AVector type TODO(palmerb4): Extend this concept to contain all shared setters and getters for our vectors.

Macros
#define	MUNDY_MATH_VECTOR_SCALAR_ATOMIC_FETCH_OP(op_name)
#define	MUNDY_MATH_VECTOR_VECTOR_ATOMIC_FETCH_OP(op_name)
#define	MUNDY_MATH_VECTOR_SCALAR_ATOMIC_OP_FETCH(op_name)
#define	MUNDY_MATH_VECTOR_VECTOR_ATOMIC_OP_FETCH(op_name)
atomic_[op] Atomic operation which don’t return anything. [op] might be add, sub, mul, div.
#define	MUNDY_MATH_VECTOR_SCALAR_ATOMIC_OP(op_name)
#define	MUNDY_MATH_VECTOR_VECTOR_ATOMIC_OP(op_name)

Typedefs
template<typename T, size_t N>
using	mundy::Vector = AVector<T, N, Array<T, N>>
	Type alias for a vector with the default accessor (Array<T, N>) This prevents the need to write AVector3d<> instead of just Vector3d.

Functions
Write to output stream
template<typename T, size_t N, ValidAccessor< T > Accessor>
std::ostream &	mundy::operator<< (std::ostream &os, const AVector< T, N, Accessor > &vec)
	Write the vector to an output stream.
Non-member comparison functions
template<typename U, typename T>
constexpr bool	mundy::is_close (const U &scalar1, const T &scalar2, const decltype(get_comparison_tolerance< T, U >())&tol=get_comparison_tolerance< T, U >())
	Scalar-scalar equality (within a tolerance).
template<typename U, typename T>
constexpr bool	mundy::is_approx_close (const U &scalar1, const T &scalar2, const decltype(get_relaxed_comparison_tolerance< T, U >())&tol=get_relaxed_comparison_tolerance< T, U >())
	Scalar-scalar equality (within a relaxed tolerance).
template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr bool	mundy::is_close (const AVector< U, N, Accessor1 > &vec1, const AVector< T, N, Accessor2 > &vec2, const decltype(get_comparison_tolerance< T, U >())&tol=get_comparison_tolerance< T, U >())
	AVector-vector equality (element-wise within a tolerance).
template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr bool	mundy::is_approx_close (const AVector< U, N, Accessor1 > &vec1, const AVector< T, N, Accessor2 > &vec2, const decltype(get_relaxed_comparison_tolerance< T, U >())&tol=get_relaxed_comparison_tolerance< T, U >())
	AVector-vector equality (element-wise within a relaxed tolerance).
Non-member addition and subtraction operators
template<size_t N, typename U, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::operator+ (const U &scalar, const AVector< T, N, Accessor > &vec) -> AVector< scalar_sum_result_t< T, U >, N >
	Scalar-vector addition.
template<size_t N, typename U, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::operator- (const U &scalar, const AVector< T, N, Accessor > &vec) -> AVector< scalar_difference_result_t< T, U >, N >
	Scalar-vector subtraction.
Non-member multiplication and division operators
template<size_t N, typename U, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::operator* (const U &scalar, const AVector< T, N, Accessor > &vec) -> AVector< scalar_product_result_t< T, U >, N >
	Scalar-vector multiplication.
Basic arithmetic reduction operations
template<size_t N, typename T, ValidAccessor< T > Accessor>
constexpr T	mundy::sum (const AVector< T, N, Accessor > &vec)
	Sum of all elements.
template<size_t N, typename T, ValidAccessor< T > Accessor>
constexpr T	mundy::product (const AVector< T, N, Accessor > &vec)
	Product of all elements.
template<size_t N, typename T, ValidAccessor< T > Accessor>
constexpr T	mundy::min (const AVector< T, N, Accessor > &vec)
	Minimum element.
template<size_t N, typename T, ValidAccessor< T > Accessor>
constexpr T	mundy::max (const AVector< T, N, Accessor > &vec)
	Maximum element.
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = typename NumTraits<T>::NonInteger>
constexpr OutputType	mundy::mean (const AVector< T, N, Accessor > &vec)
	Mean of all elements (returns a double if T is an integral type, otherwise returns T).
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<NumTraits<T>::IsInteger, float, T>>
constexpr OutputType	mundy::mean_f (const AVector< T, N, Accessor > &vec)
	Mean of all elements (returns a float if T is an integral type, otherwise returns T).
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = typename NumTraits<T>::NonInteger>
constexpr OutputType	mundy::variance (const AVector< T, N, Accessor > &vec)
	Variance of all elements (returns a double if T is an integral type, otherwise returns T).
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<NumTraits<T>::IsInteger, float, T>>
constexpr OutputType	mundy::variance_f (const AVector< T, N, Accessor > &vec)
	Variance of all elements (returns a float if T is an integral type, otherwise returns T).
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = typename NumTraits<T>::NonInteger>
constexpr OutputType	mundy::stddev (const AVector< T, N, Accessor > &vec)
	Standard deviation of all elements (returns a double if T is an integral type, otherwise returns T).
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<NumTraits<T>::IsInteger, float, T>>
constexpr OutputType	mundy::stddev_f (const AVector< T, N, Accessor > &vec)
	Standard deviation of all elements (returns a float if T is an integral type, otherwise returns T).
Special vector operations
template<ValidVectorType VectorType>
constexpr auto	mundy::copy (const VectorType &v)
	Get a deep copy of the given vector.
template<typename U, ValidVectorType VectorType>
constexpr auto	mundy::cast (const VectorType &v)
	Cast a vector to a different type.
template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::dot (const AVector< U, N, Accessor1 > &a, const AVector< T, N, Accessor2 > &b)
	Dot product of two vectors.
template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::elementwise_mul (const AVector< U, N, Accessor1 > &a, const AVector< T, N, Accessor2 > &b)
	Element-wise product.
template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::elementwise_div (const AVector< U, N, Accessor1 > &a, const AVector< T, N, Accessor2 > &b)
	Element-wise division.
template<typename Func, size_t N, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::apply (Func &&func, const AVector< T, N, Accessor > &vec)
	Apply a function to each element of the vector.
AVector norms
template<size_t N, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::abs (const AVector< T, N, Accessor > &vec)
	AVector component-wise absolute value.
template<size_t N, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::inf_norm (const AVector< T, N, Accessor > &vec)
	AVector infinity norm.
template<size_t N, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::one_norm (const AVector< T, N, Accessor > &vec)
	AVector 1-norm.
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = typename NumTraits<T>::NonInteger>
constexpr OutputType	mundy::two_norm (const AVector< T, N, Accessor > &vec)
	AVector 2-norm (Returns a double if T is an integral type, otherwise returns T).
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<NumTraits<T>::IsInteger, float, T>>
constexpr OutputType	mundy::two_norm_f (const AVector< T, N, Accessor > &vec)
	AVector 2-norm (Returns a float if T is an integral type, otherwise returns T).
template<size_t N, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::two_norm_squared (const AVector< T, N, Accessor > &vec)
	AVector squared 2-norm.
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = typename NumTraits<T>::NonInteger>
constexpr OutputType	mundy::norm (const AVector< T, N, Accessor > &vec)
	Default vector norm (2-norm, returns a double if T is an integral type, otherwise returns T).
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<NumTraits<T>::IsInteger, float, T>>
constexpr OutputType	mundy::norm_f (const AVector< T, N, Accessor > &vec)
	Default vector norm (2-norm, returns a float if T is an integral type, otherwise returns T).
template<size_t N, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::norm_squared (const AVector< T, N, Accessor > &vec)
	Default vector norm squared (2-norm).
template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2, typename OutputType = typename NumTraits<scalar_product_result_t<U, T>>::NonInteger>
constexpr OutputType	mundy::minor_angle (const AVector< U, N, Accessor1 > &a, const AVector< T, N, Accessor2 > &b)
	Minor angle between two vectors, in radians (integral inputs promote to double).
template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2, typename OutputType = std::conditional_t<NumTraits<scalar_product_result_t<U, T>>::IsInteger, float, scalar_product_result_t<U, T>>>
constexpr OutputType	mundy::minor_angle_f (const AVector< U, N, Accessor1 > &a, const AVector< T, N, Accessor2 > &b)
	Minor angle between two vectors, in radians (integral inputs promote to float).
template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2, typename OutputType = typename NumTraits<scalar_product_result_t<U, T>>::NonInteger>
constexpr OutputType	mundy::major_angle (const AVector< U, N, Accessor1 > &a, const AVector< T, N, Accessor2 > &b)
	Major angle between two vectors, in radians (integral inputs promote to double).
template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2, typename OutputType = std::conditional_t<NumTraits<scalar_product_result_t<U, T>>::IsInteger, float, scalar_product_result_t<U, T>>>
constexpr OutputType	mundy::major_angle_f (const AVector< U, N, Accessor1 > &a, const AVector< T, N, Accessor2 > &b)
	Major angle between two vectors, in radians (integral inputs promote to float).
atomic_load/store. Atomic memory management operations.
template<size_t N, typename T, ValidAccessor< T > A>
AVector< T, N >	mundy::atomic_load (AVector< T, N, A > *const v)
	Atomic v_copy = v.
template<size_t N, typename T1, ValidAccessor< T1 > A, typename T2>
void	mundy::atomic_store (AVector< T1, N, A > *const v, const T2 &s)
	Atomic v[i] = s.
template<size_t N, typename T1, ValidAccessor< T1 > A1, typename T2, ValidAccessor< T2 > A2>
void	mundy::atomic_store (AVector< T1, N, A1 > *const v1, const AVector< T2, N, A2 > &v2)
	Atomic v1[i] = v2[i].
Non-member arithmetic: AScalar op AVector / AVector op AScalar
template<size_t N, typename T, typename U, ValidAccessor< T > Accessor1, ValidAccessor< U > Accessor2>
constexpr auto	mundy::operator* (const AVector< T, N, Accessor1 > &vec, const AScalar< U, Accessor2 > &s) -> AVector< scalar_product_result_t< T, U >, N >
	AVector * AScalar.
template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::operator* (const AScalar< U, Accessor1 > &s, const AVector< T, N, Accessor2 > &vec) -> AVector< scalar_product_result_t< T, U >, N >
	AScalar * AVector (commutative).
template<size_t N, typename T, typename U, ValidAccessor< T > Accessor1, ValidAccessor< U > Accessor2>
constexpr auto	mundy::operator/ (const AVector< T, N, Accessor1 > &vec, const AScalar< U, Accessor2 > &s)
	AVector / AScalar.

Variables
template<typename TypeToCheck>
constexpr bool	mundy::is_vector_v = is_vector<TypeToCheck>::value

Type specializations
Atomic v[i] += s (returns new v) Atomic v[i] -= s (returns new v) Atomic v[i] = s (returns new v) Atomic v[i] /= s (returns new v) Atomic v1[i] += v2[i] (returns new v1) Atomic v1[i] -= v2[i] (returns new v1) Atomic v1[i] = v2[i] (returns new v1) Atomic v1[i] /= v2[i] (returns new v1)
#define	MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION(alias, alias_lower, N)
#define	MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(alias, alias_lower, T, N)
	mundy::vector2
	mundy::vector4
	mundy::vector6
	mundy::vector2d
	mundy::vector4d
	mundy::vector6d
	mundy::vector2f
	mundy::vector4f
	mundy::vector6f
	mundy::vector2i
	mundy::vector4i
	mundy::vector6i
	mundy::MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION (Vector1, vector1, 1) MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION(Vector2
	mundy::MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION (Vector3, vector3, 3) MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION(Vector4
	mundy::MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION (Vector5, vector5, 5) MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION(Vector6
	mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector1d, vector1d, double, 1) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector2d
	mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector3d, vector3d, double, 3) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector4d
	mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector5d, vector5d, double, 5) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector6d
	mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector1f, vector1f, float, 1) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector2f
	mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector3f, vector3f, float, 3) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector4f
	mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector5f, vector5f, float, 5) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector6f
	mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector1i, vector1i, int, 1) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector2i
	mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector3i, vector3i, int, 3) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector4i
	mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector5i, vector5i, int, 5) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector6i

AVector views
#define	MUNDY_MATH_GET_VECTOR_SIZE_SPECIALIZATION(alias, alias_lower, N)
#define	MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION(alias, alias_lower, T, N)
template<typename T, size_t N, ValidAccessor< T > Accessor>
constexpr auto	mundy::get_vector (Accessor &&data)
	A helper function to create a AVector<T, N, Accessor> based on a given accessor.
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_SPECIALIZATION (Vector1, vector1, 1) MUNDY_MATH_GET_VECTOR_SIZE_SPECIALIZATION(Vector2
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_SPECIALIZATION (Vector3, vector3, 3) MUNDY_MATH_GET_VECTOR_SIZE_SPECIALIZATION(Vector4
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_SPECIALIZATION (Vector5, vector5, 5) MUNDY_MATH_GET_VECTOR_SIZE_SPECIALIZATION(Vector6
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION (Vector1d, vector1d, double, 1) MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION(Vector2d
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION (Vector3d, vector3d, double, 3) MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION(Vector4d
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION (Vector5d, vector5d, double, 5) MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION(Vector6d
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION (Vector1f, vector1f, float, 1) MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION(Vector2f
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION (Vector3f, vector3f, float, 3) MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION(Vector4f
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION (Vector5f, vector5f, float, 5) MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION(Vector6f
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION (Vector1i, vector1i, int, 1) MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION(Vector2i
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION (Vector3i, vector3i, int, 3) MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION(Vector4i
	mundy::MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION (Vector5i, vector5i, int, 5) MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION(Vector6i

Macro Definition Documentation

◆ MUNDY_MATH_VECTOR_SCALAR_ATOMIC_OP

#define MUNDY_MATH_VECTOR_SCALAR_ATOMIC_OP ( op_name )

Value:

template <size_t N, typename T1, ValidAccessor<T1> A1, typename T2>                      \
KOKKOS_INLINE_FUNCTION void atomic_##op_name(AVector<T1, N, A1>* const v, const T2& s) { \
  impl::atomic_vector_scalar_##op_name##_impl(std::make_index_sequence<N>{}, v, s);      \
}

◆ MUNDY_MATH_VECTOR_VECTOR_ATOMIC_OP

#define MUNDY_MATH_VECTOR_VECTOR_ATOMIC_OP ( op_name )

Value:

template <size_t N, typename T1, ValidAccessor<T1> A1, typename T2, ValidAccessor<T2> A2>                  \
KOKKOS_INLINE_FUNCTION void atomic_##op_name(AVector<T1, N, A1>* const v1, const AVector<T2, N, A2>& v2) { \
  impl::atomic_vector_vector_##op_name##_impl(std::make_index_sequence<N>{}, v1, v2);                      \
}

◆ MUNDY_MATH_VECTOR_SCALAR_ATOMIC_FETCH_OP

#define MUNDY_MATH_VECTOR_SCALAR_ATOMIC_FETCH_OP ( op_name )

Value:

template <size_t N, typename T1, ValidAccessor<T1> A1, typename T2>                              \
KOKKOS_INLINE_FUNCTION auto atomic_fetch_##op_name(AVector<T1, N, A1>* const v, const T2& s) {   \
  return impl::vector_scalar_atomic_fetch_##op_name##_impl(std::make_index_sequence<N>{}, v, s); \
}

◆ MUNDY_MATH_VECTOR_VECTOR_ATOMIC_FETCH_OP

#define MUNDY_MATH_VECTOR_VECTOR_ATOMIC_FETCH_OP ( op_name )

Value:

template <size_t N, typename T1, ValidAccessor<T1> A1, typename T2, ValidAccessor<T2> A2>                        \
KOKKOS_INLINE_FUNCTION auto atomic_fetch_##op_name(AVector<T1, N, A1>* const v1, const AVector<T2, N, A2>& v2) { \
  return impl::vector_vector_atomic_fetch_##op_name##_impl(std::make_index_sequence<N>{}, v1, v2);               \
}

◆ MUNDY_MATH_VECTOR_SCALAR_ATOMIC_OP_FETCH

#define MUNDY_MATH_VECTOR_SCALAR_ATOMIC_OP_FETCH ( op_name )

Value:

template <size_t N, typename T1, ValidAccessor<T1> A1, typename T2>                              \
KOKKOS_INLINE_FUNCTION auto atomic_##op_name##_fetch(AVector<T1, N, A1>* const v, const T2& s) { \
  return impl::vector_scalar_atomic_##op_name##_fetch_impl(std::make_index_sequence<N>{}, v, s); \
}

◆ MUNDY_MATH_VECTOR_VECTOR_ATOMIC_OP_FETCH

#define MUNDY_MATH_VECTOR_VECTOR_ATOMIC_OP_FETCH ( op_name )

Value:

template <size_t N, typename T1, ValidAccessor<T1> A1, typename T2, ValidAccessor<T2> A2>                          \
KOKKOS_INLINE_FUNCTION auto atomic_##op_name##_fetch(AVector<T1, N, A1>* const v1, const AVector<T2, N, A2>& v2) { \
  return impl::vector_vector_atomic_##op_name##_fetch_impl(std::make_index_sequence<N>{}, v1, v2);                 \
}

◆ MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION

#define MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION	(	alias,
		alias_lower,
		N )

Value:

template <typename T, ValidAccessor<T> Accessor = Array<T, N>>                          \
using A##alias = AVector<T, N, Accessor>;                                               \
template <typename T>                                                                   \
using alias = A##alias<T>;                                                              \
template <typename TypeToCheck>                                                         \
struct is_##alias_lower##_impl : std::false_type {};                                    \
template <typename T, typename Accessor>                                                \
struct is_##alias_lower##_impl<A##alias<T, Accessor>> : std::true_type {};              \
template <typename TypeToCheck>                                                         \
struct is_##alias_lower : public is_##alias_lower##_impl<std::decay_t<TypeToCheck>> {}; \
template <typename TypeToCheck>                                                         \
constexpr bool is_##alias_lower##_v = is_##alias_lower<TypeToCheck>::value;

◆ MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION

#define MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION	(	alias,
		alias_lower,
		T,
		N )

Value:

template <ValidAccessor<T> Accessor = Array<T, N>>                                      \
using A##alias = AVector<T, N, Accessor>;                                               \
using alias = A##alias<>;                                                               \
template <typename TypeToCheck>                                                         \
struct is_##alias_lower##_impl : std::false_type {};                                    \
template <typename Accessor>                                                            \
struct is_##alias_lower##_impl<A##alias<Accessor>> : std::true_type {};                 \
template <typename TypeToCheck>                                                         \
struct is_##alias_lower : public is_##alias_lower##_impl<std::decay_t<TypeToCheck>> {}; \
template <typename TypeToCheck>                                                         \
constexpr bool is_##alias_lower##_v = is_##alias_lower<TypeToCheck>::value;

◆ MUNDY_MATH_GET_VECTOR_SIZE_SPECIALIZATION

#define MUNDY_MATH_GET_VECTOR_SIZE_SPECIALIZATION	(	alias,
		alias_lower,
		N )

Value:

template <typename T, ValidAccessor<T> Accessor>                           \
KOKKOS_INLINE_FUNCTION constexpr auto get_##alias_lower(Accessor&& data) { \
  return get_vector<T, N>(std::forward<Accessor>(data));                   \
}

◆ MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION

#define MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION	(	alias,
		alias_lower,
		T,
		N )

Value:

template <ValidAccessor<T> Accessor>                                               \
KOKKOS_INLINE_FUNCTION constexpr auto get_##alias_lower(Accessor&& data) {         \
  return get_vector<T, N>(std::forward<Accessor>(data));                           \
}

Classes

Namespaces

Concepts

Macros

Typedefs

Functions

Variables

Type specializations

AVector views

Macro Definition Documentation

◆ MUNDY_MATH_VECTOR_SCALAR_ATOMIC_OP

◆ MUNDY_MATH_VECTOR_VECTOR_ATOMIC_OP

◆ MUNDY_MATH_VECTOR_SCALAR_ATOMIC_FETCH_OP

◆ MUNDY_MATH_VECTOR_VECTOR_ATOMIC_FETCH_OP

◆ MUNDY_MATH_VECTOR_SCALAR_ATOMIC_OP_FETCH

◆ MUNDY_MATH_VECTOR_VECTOR_ATOMIC_OP_FETCH

◆ MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION

◆ MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION

◆ MUNDY_MATH_GET_VECTOR_SIZE_SPECIALIZATION

◆ MUNDY_MATH_GET_VECTOR_SIZE_AND_TYPE_SPECIALIZATION