Classes | |
| class | mundy::AVector< T, N, Accessor > |
| Class for an Nx1 vector with arithmetic entries. 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) |
| #define | MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION(alias, alias_lower, N) |
| #define | MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(alias, alias_lower, T, N) |
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< std::common_type_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< std::common_type_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< std::common_type_t< T, U >, N > |
| Scalar-vector multiplication. | |
Basic arithmetic reduction operations | |
| template<size_t N, typename T, ValidAccessor< T > Accessor> | |
| constexpr auto | mundy::sum (const AVector< T, N, Accessor > &vec) |
| Sum of all elements. | |
| template<size_t N, typename T, ValidAccessor< T > Accessor> | |
| constexpr auto | mundy::product (const AVector< T, N, Accessor > &vec) |
| Product of all elements. | |
| template<size_t N, typename T, ValidAccessor< T > Accessor> | |
| constexpr auto | mundy::min (const AVector< T, N, Accessor > &vec) |
| Minimum element. | |
| template<size_t N, typename T, ValidAccessor< T > Accessor> | |
| constexpr auto | mundy::max (const AVector< T, N, Accessor > &vec) |
| Maximum element. | |
| template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<std::is_integral_v<T>, double, T>> | |
| 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<std::is_integral_v<T>, 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 = std::conditional_t<std::is_integral_v<T>, double, T>> | |
| 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<std::is_integral_v<T>, 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 = std::conditional_t<std::is_integral_v<T>, double, T>> | |
| 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<std::is_integral_v<T>, 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 arithmetic 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) -> std::common_type_t< T, U > |
| 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 = std::conditional_t<std::is_integral_v<T>, double, T>> | |
| 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<std::is_integral_v<T>, 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 = std::conditional_t<std::is_integral_v<T>, double, T>> | |
| 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<std::is_integral_v<T>, 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 = std::conditional_t<std::is_integral_v<std::common_type_t<U, T>>, double, std::common_type_t<U, T>>> | |
| constexpr OutputType | mundy::minor_angle (const AVector< U, N, Accessor1 > &a, const AVector< T, N, Accessor2 > &b) |
| Minor angle between two vectors (returns a double if common_type_t<U, T> is integral, otherwise common_type_t<U, T>). | |
| template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2, typename OutputType = std::conditional_t<std::is_integral_v<std::common_type_t<U, T>>, float, std::common_type_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 (returns a float if common_type_t<U, T> is integral, otherwise common_type_t<U, T>). | |
| template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2, typename OutputType = std::conditional_t<std::is_integral_v<std::common_type_t<U, T>>, double, std::common_type_t<U, T>>> | |
| constexpr OutputType | mundy::major_angle (const AVector< U, N, Accessor1 > &a, const AVector< T, N, Accessor2 > &b) |
| Major angle between two vectors (returns a double if common_type_t<U, T> is integral, otherwise common_type_t<U, T>). | |
| template<size_t N, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2, typename OutputType = std::conditional_t<std::is_integral_v<std::common_type_t<U, T>>, float, std::common_type_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 (returns a float if common_type_t<U, T> is integral, otherwise common_type_t<U, T>). | |
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]. | |
AVector views | |
| size_t ValidAccessor< T > Accessor constexpr auto | mundy::get_vector_view (Accessor &&data) |
| template<typename T, size_t N, ValidAccessor< T > Accessor> | |
| constexpr auto | mundy::get_owning_vector (Accessor &&data) |
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) | |
| mundy::vector1 | |
| mundy::vector3 | |
| mundy::vector5 | |
| mundy::vector1d | |
| mundy::vector3d | |
| mundy::vector5d | |
| mundy::vector1f | |
| mundy::vector3f | |
| mundy::vector5f | |
| mundy::vector1i | |
| mundy::vector3i | |
| mundy::vector5i | |
| mundy::MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION (Vector2, vector2, 2) MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION(Vector3 | |
| mundy::MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION (Vector4, vector4, 4) MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION(Vector5 | |
| mundy::MUNDY_MATH_VECTOR_SIZE_SPECIALIZATION (Vector6, vector6, 6) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector1d | |
| mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector2d, vector2d, double, 2) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector3d | |
| mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector4d, vector4d, double, 4) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector5d | |
| mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector6d, vector6d, double, 6) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector1f | |
| mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector2f, vector2f, float, 2) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector3f | |
| mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector4f, vector4f, float, 4) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector5f | |
| mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector6f, vector6f, float, 6) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector1i | |
| mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector2i, vector2i, int, 2) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector3i | |
| mundy::MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION (Vector4i, vector4i, int, 4) MUNDY_MATH_VECTOR_TYPE_AND_SIZE_SPECIALIZATION(Vector5i | |
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>> \
MUNDY_REQUIRES(std::is_arithmetic_v<T>) \
using A##alias = AVector<T, N, Accessor>; \
template <typename T> \
MUNDY_REQUIRES(std::is_arithmetic_v<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;
Generated by
1.17.0