Classes
class	mundy::AMatrix< T, N, M, Accessor >
	Class for an NxM (num rows x num columns) matrix with arithmetic entries. More...

Namespaces
namespace	mundy

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

Macros
#define	MUNDY_MATH_MATRIX_SCALAR_ATOMIC_FETCH_OP(op_name)
#define	MUNDY_MATH_MATRIX_MATRIX_ATOMIC_FETCH_OP(op_name)
#define	MUNDY_MATH_MATRIX_SCALAR_ATOMIC_OP_FETCH(op_name)
#define	MUNDY_MATH_MATRIX_MATRIX_ATOMIC_OP_FETCH(op_name)
atomic_[op] Atomic operation which don’t return anything. [op] might be add, sub, elementwise_mul,
elementwise_div.
#define	MUNDY_MATH_MATRIX_SCALAR_ATOMIC_OP(op_name)
#define	MUNDY_MATH_MATRIX_MATRIX_ATOMIC_OP(op_name)

Typedefs
template<typename T, size_t N, size_t M>
using	mundy::Matrix = AMatrix<T, N, M, Array<T, N * M>>
	Shorthand name for AMatrix with default accessor.

Functions
Write to output stream
template<typename T, size_t N, size_t M, ValidAccessor< T > Accessor>
std::ostream &	mundy::operator<< (std::ostream &os, const AMatrix< T, N, M, Accessor > &mat)
	Write the matrix to an output stream.
Non-member comparison functions
template<size_t N, size_t M, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr bool	mundy::is_close (const AMatrix< U, N, M, Accessor1 > &mat1, const AMatrix< T, N, M, Accessor2 > &mat2, const decltype(get_comparison_tolerance< T, U >())&tol=get_comparison_tolerance< T, U >())
	AMatrix-matrix equality (element-wise within a tolerance).
template<size_t N, size_t M, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr bool	mundy::is_approx_close (const AMatrix< U, N, M, Accessor1 > &mat1, const AMatrix< T, N, M, Accessor2 > &mat2, const decltype(get_relaxed_comparison_tolerance< T, U >())&tol=get_relaxed_comparison_tolerance< T, U >())
	AMatrix-matrix equality (element-wise within a relaxed tolerance).
Non-member addition and subtraction operators
template<size_t N, size_t M, typename U, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::operator+ (const U &scalar, const AMatrix< T, N, M, Accessor > &mat) -> AMatrix< std::common_type_t< T, U >, N, M >
	Scalar-matrix addition.
template<size_t N, size_t M, typename U, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::operator- (const U &scalar, const AMatrix< T, N, M, Accessor > &mat) -> AMatrix< std::common_type_t< T, U >, N, M >
	Scalar-matrix subtraction.
Non-member multiplication and division operators
template<size_t N, size_t M, typename U, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::operator* (const U &scalar, const AMatrix< T, N, M, Accessor > &mat) -> AMatrix< std::common_type_t< T, U >, N, M >
	Scalar-matrix multiplication.
template<size_t N, size_t M, typename U, typename T, ValidAccessor< T > Accessor1, ValidAccessor< U > Accessor2>
constexpr auto	mundy::operator* (const AVector< U, N, Accessor1 > &vec, const AMatrix< T, N, M, Accessor2 > &mat) -> Vector< std::common_type_t< T, U >, M >
	Vector matrix multiplication (v^T M).
Basic arithmetic reduction operations
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::determinant (const AMatrix< T, N, M, Accessor > &mat)
	AMatrix determinant.
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::trace (const AMatrix< T, N, M, Accessor > &mat)
	AMatrix trace.
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::sum (const AMatrix< T, N, M, Accessor > &mat)
	Sum of all elements.
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::product (const AMatrix< T, N, M, Accessor > &mat)
	Product of all elements.
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::min (const AMatrix< T, N, M, Accessor > &mat)
	Minimum element of the matrix.
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::max (const AMatrix< T, N, M, Accessor > &mat)
	Maximum element of the matrix.
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<std::is_integral_v<T>, double, T>>
constexpr OutputType	mundy::mean (const AMatrix< T, N, M, Accessor > &mat)
	Mean of all elements (returns a double if T is an integral type, otherwise returns T).
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<std::is_integral_v<T>, float, T>>
constexpr OutputType	mundy::mean_f (const AMatrix< T, N, M, Accessor > &mat)
	Mean of all elements (returns a float if T is an integral type, otherwise returns T).
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<std::is_integral_v<T>, double, T>>
constexpr OutputType	mundy::variance (const AMatrix< T, N, M, Accessor > &mat)
	Variance of all elements (returns a double if T is an integral type, otherwise returns T).
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<std::is_integral_v<T>, float, T>>
constexpr OutputType	mundy::variance_f (const AMatrix< T, N, M, Accessor > &mat)
	Variance of all elements (returns a float if T is an integral type, otherwise returns T).
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<std::is_integral_v<T>, double, T>>
constexpr OutputType	mundy::stddev (const AMatrix< T, N, M, Accessor > &mat)
	Standard deviation of all elements (returns a double if T is an integral type, otherwise returns T).
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<std::is_integral_v<T>, float, T>>
constexpr OutputType	mundy::stddev_f (const AMatrix< T, N, M, Accessor > &mat)
	Standard deviation of all elements (returns a float if T is an integral type, otherwise returns T).
Special matrix operations
template<ValidMatrixType MatrixType>
constexpr auto	mundy::copy (const MatrixType &m)
	Get a deep copy of the given matrix.
template<typename U, ValidMatrixType MatrixType>
constexpr auto	mundy::cast (const MatrixType &m)
	Cast a matrix to a different arithmetic type.
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr AMatrix< T, M, N >	mundy::transpose (const AMatrix< T, N, M, Accessor > &mat)
	AMatrix transpose.
template<size_t N, typename T, ValidAccessor< T > Accessor>
AMatrix< T, N, N > constexpr	mundy::cofactors (const AMatrix< T, N, N, Accessor > &mat)
	AMatrix cofactors.
template<size_t N, typename T, ValidAccessor< T > Accessor>
AMatrix< T, N, N > constexpr	mundy::adjugate (const AMatrix< T, N, N, Accessor > &mat)
	AMatrix adjugate.
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputType = std::conditional_t<std::is_integral_v<T>, double, T>>
AMatrix< OutputType, N, N > constexpr	mundy::inverse (const AMatrix< T, N, N, Accessor > &mat)
template<size_t N, typename T, ValidAccessor< T > Accessor, typename OutputElementType = std::conditional_t<std::is_integral_v<T>, float, T>>
constexpr auto	mundy::inverse_f (const AMatrix< T, N, N, Accessor > &mat)
	AMatrix inverse (returns a float if T is an integral type, otherwise returns T).
template<size_t N, size_t M, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::frobenius_inner_product (const AMatrix< U, N, M, Accessor1 > &a, const AMatrix< T, N, M, Accessor2 > &b)
	AMatrix Frobenius inner product.
template<size_t N, size_t M, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::elementwise_mul (const AMatrix< U, N, M, Accessor1 > &a, const AMatrix< T, N, M, Accessor2 > &b)
	Element-wise product.
template<size_t N, size_t M, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::elementwise_div (const AMatrix< U, N, M, Accessor1 > &a, const AMatrix< T, N, M, Accessor2 > &b)
	Element-wise product.
template<typename Func, size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::apply (Func &&func, const AMatrix< T, N, M, Accessor > &mat)
	Apply a function to each element of the matrix.
template<typename Func, size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::apply_row (Func &&func, const AMatrix< T, N, M, Accessor > &mat)
	Apply a function to each row of the matrix.
template<typename Func, size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::apply_column (Func &&func, const AMatrix< T, N, M, Accessor > &mat)
	Apply a function to each column of the matrix.
Special vector operations with matrices
template<size_t N, size_t M, typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::outer_product (const AVector< U, N, Accessor1 > &a, const AVector< T, M, Accessor2 > &b)
	Outer product of two vectors.
AMatrix norms
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::frobenius_norm (const AMatrix< T, N, M, Accessor > &mat)
	AMatrix Frobenius norm.
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::inf_norm (const AMatrix< T, N, M, Accessor > &mat)
	AMatrix infinity norm.
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::one_norm (const AMatrix< T, N, M, Accessor > &mat)
	AMatrix 1-norm (maximum absolute column sum).
template<size_t N, size_t M, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::two_norm (const AMatrix< T, N, M, Accessor > &mat)
	AMatrix 2-norm.
atomic_load/store. Atomic memory management operations.
template<size_t N, size_t M, typename T, ValidAccessor< T > A>
AMatrix< T, N, M >	mundy::atomic_load (AMatrix< T, N, M, A > *const m)
	Atomic m_copy = m.
template<size_t N, size_t M, typename T1, ValidAccessor< T1 > A, typename T2>
void	mundy::atomic_store (AMatrix< T1, N, M, A > *const m, const T2 &s)
	Atomic m[i, j] = s.
template<size_t N, size_t M, typename T1, ValidAccessor< T1 > A1, typename T2, ValidAccessor< T2 > A2>
void	mundy::atomic_store (AMatrix< T1, N, M, A1 > *const m1, const AMatrix< T2, N, M, A2 > &m2)
	Atomic m1[i, j] = m2[i, j].

Variables
template<typename TypeToCheck>
constexpr bool	mundy::is_matrix_v = is_matrix<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_MATRIX_SIZE_SPECIALIZATION_IMPL(alias, alias_lower, N, M)
#define	MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(alias, alias_lower, T, N, M)
#define	MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION(N, M)
#define	MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_FLOAT_DOUBLE(N, M)
#define	MUNDY_MATH_MATRIX_EXPAND_1_TO_6_1D(macro_1d)
#define	MUNDY_MATH_MATRIX_EXPAND_1_TO_6_2D(macro_2d)
	mundy::matrix1
	mundy::matrix3
	mundy::matrix5
	mundy::matrix1f
	mundy::float
	mundy::matrix3f
	mundy::matrix5f
	mundy::matrix1d
	mundy::double
	mundy::matrix3d
	mundy::matrix5d
	mundy::matrix1i
	mundy::int
	mundy::matrix3i
	mundy::matrix5i
	mundy::MUNDY_MATH_MATRIX_EXPAND_1_TO_6_2D (MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION) MUNDY_MATH_MATRIX_EXPAND_1_TO_6_2D(MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_FLOAT_DOUBLE) MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL(Matrix1
	AMatrix specializations.
	mundy::MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL (Matrix2, matrix2, 2, 2) MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL(Matrix3
	mundy::MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL (Matrix4, matrix4, 4, 4) MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL(Matrix5
	mundy::MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL (Matrix6, matrix6, 6, 6) MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(Matrix1f
	mundy::MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL (Matrix2f, matrix2f, float, 2, 2) MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(Matrix3f
	mundy::MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL (Matrix4f, matrix4f, float, 4, 4) MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(Matrix5f
	mundy::MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL (Matrix6f, matrix6f, float, 6, 6) MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(Matrix1d
	mundy::MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL (Matrix2d, matrix2d, double, 2, 2) MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(Matrix3d
	mundy::MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL (Matrix4d, matrix4d, double, 4, 4) MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(Matrix5d
	mundy::MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL (Matrix6d, matrix6d, double, 6, 6) MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(Matrix1i
	mundy::MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL (Matrix2i, matrix2i, int, 2, 2) MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(Matrix3i
	mundy::MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL (Matrix4i, matrix4i, int, 4, 4) MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(Matrix5i

AMatrix<T, Accessor> views
size_t	mundy::N
size_t size_t	mundy::M
size_t size_t ValidAccessor< T > Accessor constexpr auto	mundy::get_matrix_view (Accessor &&data)
template<typename T, size_t N, size_t M, ValidAccessor< T > Accessor>
constexpr auto	mundy::get_owning_matrix (Accessor &&data)

Macro Definition Documentation

◆ MUNDY_MATH_MATRIX_SCALAR_ATOMIC_OP

#define MUNDY_MATH_MATRIX_SCALAR_ATOMIC_OP ( op_name )

Value:

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

◆ MUNDY_MATH_MATRIX_MATRIX_ATOMIC_OP

#define MUNDY_MATH_MATRIX_MATRIX_ATOMIC_OP ( op_name )

Value:

template <size_t N, size_t M, typename T1, ValidAccessor<T1> A1, typename T2, ValidAccessor<T2> A2>              \
KOKKOS_INLINE_FUNCTION void atomic_##op_name(AMatrix<T1, N, M, A1>* const m1, const AMatrix<T2, N, M, A2>& m2) { \
  impl::atomic_matrix_matrix_##op_name##_impl(std::make_index_sequence<N * M>{}, m1, m2);                        \
}

◆ MUNDY_MATH_MATRIX_SCALAR_ATOMIC_FETCH_OP

#define MUNDY_MATH_MATRIX_SCALAR_ATOMIC_FETCH_OP ( op_name )

Value:

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

◆ MUNDY_MATH_MATRIX_MATRIX_ATOMIC_FETCH_OP

#define MUNDY_MATH_MATRIX_MATRIX_ATOMIC_FETCH_OP ( op_name )

Value:

template <size_t N, size_t M, typename T1, ValidAccessor<T1> A1, typename T2, ValidAccessor<T2> A2>    \
KOKKOS_INLINE_FUNCTION auto atomic_fetch_##op_name(AMatrix<T1, N, M, A1>* const m1,                    \
                                                   const AMatrix<T2, N, M, A2>& m2) {                  \
  return impl::matrix_matrix_atomic_fetch_##op_name##_impl(std::make_index_sequence<N * M>{}, m1, m2); \
}

◆ MUNDY_MATH_MATRIX_SCALAR_ATOMIC_OP_FETCH

#define MUNDY_MATH_MATRIX_SCALAR_ATOMIC_OP_FETCH ( op_name )

Value:

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

◆ MUNDY_MATH_MATRIX_MATRIX_ATOMIC_OP_FETCH

#define MUNDY_MATH_MATRIX_MATRIX_ATOMIC_OP_FETCH ( op_name )

Value:

template <size_t N, size_t M, typename T1, ValidAccessor<T1> A1, typename T2, ValidAccessor<T2> A2>    \
KOKKOS_INLINE_FUNCTION auto atomic_##op_name##_fetch(AMatrix<T1, N, M, A1>* const m1,                  \
                                                     const AMatrix<T2, N, M, A2>& m2) {                \
  return impl::matrix_matrix_atomic_##op_name##_fetch_impl(std::make_index_sequence<N * M>{}, m1, m2); \
}

◆ MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL

#define MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL	(	alias,
		alias_lower,
		N,
		M )

Value:

template <typename T, ValidAccessor<T> Accessor = Array<T, N * M>>                      \
MUNDY_REQUIRES(std::is_arithmetic_v<T>)                                                 \
using A##alias = AMatrix<T, N, M, 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_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL

#define MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL	(	alias,
		alias_lower,
		T,
		N,
		M )

Value:

template <ValidAccessor<T> Accessor = Array<T, N * M>>                                  \
using A##alias = AMatrix<T, N, M, 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_MATRIX_SIZE_SPECIALIZATION

#define MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION	(		N,
			M )

Value:

MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL(AMatrix##N##M, matrix##N##M, N, M)

MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL

#define MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL(alias, alias_lower, N, M)

Definition Matrix.hpp:1289

◆ MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_FLOAT_DOUBLE

#define MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_FLOAT_DOUBLE	(		N,
			M )

Value:

MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(AMatrix##N##M##f, matrix##N##M##f, float, N, M) \

MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(AMatrix##N##M##d, matrix##N##M##d, double, N, M)

MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL

#define MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL(alias, alias_lower, T, N, M)

Definition Matrix.hpp:1305

◆ MUNDY_MATH_MATRIX_EXPAND_1_TO_6_1D

#define MUNDY_MATH_MATRIX_EXPAND_1_TO_6_1D ( macro_1d )

Value:

macro_1d(1) macro_1d(2) macro_1d(3) macro_1d(4) macro_1d(5) macro_1d(6)

◆ MUNDY_MATH_MATRIX_EXPAND_1_TO_6_2D

#define MUNDY_MATH_MATRIX_EXPAND_1_TO_6_2D ( macro_2d )

Value:

macro_2d(1, 1) macro_2d(1, 2) macro_2d(1, 3) macro_2d(1, 4) macro_2d(1, 5) macro_2d(1, 6) \
macro_2d(2, 1) macro_2d(2, 2) macro_2d(2, 3) macro_2d(2, 4) macro_2d(2, 5) macro_2d(2, 6) \
macro_2d(3, 1) macro_2d(3, 2) macro_2d(3, 3) macro_2d(3, 4) macro_2d(3, 5) macro_2d(3, 6) \
macro_2d(4, 1) macro_2d(4, 2) macro_2d(4, 3) macro_2d(4, 4) macro_2d(4, 5) macro_2d(4, 6) \
macro_2d(5, 1) macro_2d(5, 2) macro_2d(5, 3) macro_2d(5, 4) macro_2d(5, 5) macro_2d(5, 6) \
macro_2d(6, 1) macro_2d(6, 2) macro_2d(6, 3) macro_2d(6, 4) macro_2d(6, 5) macro_2d(6, 6)

Classes

Namespaces

Concepts

Macros

Typedefs

Functions

Variables

Type specializations

AMatrix<T, Accessor> views

Macro Definition Documentation

◆ MUNDY_MATH_MATRIX_SCALAR_ATOMIC_OP

◆ MUNDY_MATH_MATRIX_MATRIX_ATOMIC_OP

◆ MUNDY_MATH_MATRIX_SCALAR_ATOMIC_FETCH_OP

◆ MUNDY_MATH_MATRIX_MATRIX_ATOMIC_FETCH_OP

◆ MUNDY_MATH_MATRIX_SCALAR_ATOMIC_OP_FETCH

◆ MUNDY_MATH_MATRIX_MATRIX_ATOMIC_OP_FETCH

◆ MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION_IMPL

◆ MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_IMPL

◆ MUNDY_MATH_MATRIX_SIZE_SPECIALIZATION

◆ MUNDY_MATH_MATRIX_TYPE_AND_SIZE_SPECIALIZATION_FLOAT_DOUBLE

◆ MUNDY_MATH_MATRIX_EXPAND_1_TO_6_1D

◆ MUNDY_MATH_MATRIX_EXPAND_1_TO_6_2D