SuperDex Physics C++ API
Loading...
Searching...
No Matches
vmatrix.h File Reference
#include <mochi_core/utils/nd_array.h>
#include <mochi_core/utils/simd.h>
#include <mochi_core/utils/span.h>

Go to the source code of this file.

Namespaces

namespace  superdex

Macros

#define MOCHI_DETAILS_NDARRAY_SIMD_MEMBERWISE_OP(OP_EQ, OP)
#define MOCHI_DETAILS_UNROLL_OP_SCALAR_ARRAY(result, OP, a, b)

Typedefs

using superdex::VMatrix2x2f = Simd<float, 4>
using superdex::VMatrix2x2r = Simd<real, 4>
 Special case for the SIMD representation of a 2x2 matrix.
using superdex::VMatrix2x3f = NdArray<Simd<float, 4>, 2>
using superdex::VMatrix2x3r = NdArray<Simd<real, 4>, 2>
using superdex::VMatrix2x4f = NdArray<Simd<float, 4>, 2>
using superdex::VMatrix2x4r = NdArray<Simd<real, 4>, 2>
using superdex::VMatrix3x2f = NdArray<Simd<float, 4>, 3>
using superdex::VMatrix3x2r = NdArray<Simd<real, 4>, 3>
 SIMD representation of a NxM matrices.
using superdex::VMatrix3x3d = NdArray<Simd<double, 4>, 3>
using superdex::VMatrix3x3f = NdArray<Simd<float, 4>, 3>
using superdex::VMatrix3x3r = NdArray<Simd<real, 4>, 3>
using superdex::VMatrix3x4f = NdArray<Simd<float, 4>, 3>
using superdex::VMatrix3x4r = NdArray<Simd<real, 4>, 3>
using superdex::VMatrix4x3f = NdArray<Simd<float, 4>, 4>
using superdex::VMatrix4x3r = NdArray<Simd<real, 4>, 4>
using superdex::VMatrix4x4f = NdArray<Simd<float, 4>, 4>
using superdex::VMatrix4x4r = NdArray<Simd<real, 4>, 4>
using superdex::VSymMatrix2x2f = Simd<float, 4>
using superdex::VSymMatrix2x2r = Simd<real, 4>
 Special case for the SIMD representation of a 2x2 symmetric matrix.
using superdex::VSymMatrix3x3f = NdArray<Simd<float, 4>, 2>
using superdex::VSymMatrix3x3r = NdArray<Simd<real, 4>, 2>
 Special case for the SIMD representation of a 3x3 symmetric matrix.
using superdex::VTensor3x3x3f = NdArray<Simd<float, 4>, 3, 3>
using superdex::VTensor3x3x3r = NdArray<Simd<real, 4>, 3, 3>
using superdex::VTensor3x3x3x3f = NdArray<Simd<float, 4>, 3, 3, 3>
using superdex::VTensor3x3x3x3r = NdArray<Simd<real, 4>, 3, 3, 3>
 SIMD representation of tensors.
using superdex::VTensor4x3x3r = NdArray<Simd<real, 4>, 4, 3>

Functions

template<class V, int N, std::enable_if_t< IsSimd< V > &&N > = 3, superdex::ConceptMatch>
NdArray< V, 3 > superdex::Broadcast3 (Simd< typename V::Scalar, N > const &a)
template<class V, size_t D0, int D1, std::enable_if_t< IsSimd< V > &&D0 > = 3 && D1 >= 3, superdex::ConceptMatch>
NdArray< V, 3, 3 > superdex::Broadcast3x3 (NdArray< Simd< typename V::Scalar, D1 >, D0 > const &a)
template<class V, size_t D0, size_t... DIMS, std::enable_if_t< IsSimd< V >, superdex::ConceptMatch > = superdex::ConceptMatch::True>
NdArray< V, D0, DIMS... > superdex::BroadcastEach (NdArray< typename V::Scalar, D0, DIMS... > const &a)
template<class V, int N, std::enable_if_t< IsSimd< V >, superdex::ConceptMatch > = superdex::ConceptMatch::True>
NdArray< V, N > superdex::BroadcastEach (Simd< typename V::Scalar, N > const &a)
template<size_t D0, size_t D1, typename T>
void superdex::LoadMatrix (NdArray< Simd< T, 4 >, D0 > &out, NdArray< T, D0, D1 > const &x)
template<size_t D0, size_t D1, typename T, typename ConstOrNonConstT>
void superdex::LoadMatrix (NdArray< Simd< T, 4 >, D0 > &out, Span< ConstOrNonConstT > x)
template<size_t D0, size_t D1, typename T>
void superdex::LoadMatrix (NdArray< Simd< T, 4 >, D0 > &out, T const *x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T>
void superdex::LoadMatrix (NdArray< Simd< T, 4 >, D0, D1, D2 > &out, NdArray< T, D0, D1, D2, D3 > const &x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T>
void superdex::LoadMatrix (NdArray< Simd< T, 4 >, D0, D1, D2 > &out, T const *x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T>
void superdex::LoadSubmatrix (NdArray< Simd< T, 4 >, D0 > &out, Int2 coords, NdArray< T, D2, D3 > const &x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T, typename ConstOrNonConstT>
void superdex::LoadSubmatrix (NdArray< Simd< T, 4 >, D0 > &out, Int2 coords, Span< ConstOrNonConstT > x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T>
void superdex::LoadSubmatrix (NdArray< Simd< T, 4 >, D0 > &out, Int2 coords, Span< T > x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T>
void superdex::LoadSubmatrix (NdArray< Simd< T, 4 >, D0 > &out, Int2 coords, T const *x)
template<int kTupleCount = -1, class V, std::enable_if_t< IsSimd< V >, superdex::ConceptMatch > = superdex::ConceptMatch::True>
void superdex::LoadTransposed (typename V::Scalar const *ptr, NdArray< V, 3 > &out)
template<typename T, size_t D0, size_t... DIMS>
constexpr bool superdex::operator!= (NdArray< Simd< T, 4 >, D0, DIMS... > const &lhs, NdArray< Simd< T, 4 >, D0, DIMS... > const &rhs)
template<typename T, int N, size_t D0, size_t... DIMS>
constexpr NdArray< Simd< T, N >, D0, DIMS... > superdex::operator* (NdArray< Simd< T, N >, D0, DIMS... > const &lhs, T rhs)
template<typename T, int N, size_t D0, size_t... DIMS>
constexpr NdArray< Simd< T, N >, D0, DIMS... > superdex::operator* (T lhs, NdArray< Simd< T, N >, D0, DIMS... > const &rhs)
template<typename T, int N, size_t D0, size_t... DIMS>
constexpr NdArray< Simd< T, N >, D0, DIMS... > superdex::operator+ (NdArray< Simd< T, N >, D0, DIMS... > const &lhs, T rhs)
template<typename T, int N, size_t D0, size_t... DIMS>
constexpr NdArray< Simd< T, N >, D0, DIMS... > superdex::operator+ (T lhs, NdArray< Simd< T, N >, D0, DIMS... > const &rhs)
template<typename T, int N, size_t D0, size_t... DIMS>
constexpr NdArray< Simd< T, N >, D0, DIMS... > superdex::operator- (NdArray< Simd< T, N >, D0, DIMS... > const &lhs, T rhs)
template<typename T, int N, size_t D0, size_t... DIMS>
constexpr NdArray< Simd< T, N >, D0, DIMS... > superdex::operator- (T lhs, NdArray< Simd< T, N >, D0, DIMS... > const &rhs)
template<typename T, int N, size_t D0, size_t... DIMS>
constexpr NdArray< Simd< T, N >, D0, DIMS... > superdex::operator/ (NdArray< Simd< T, N >, D0, DIMS... > const &lhs, T rhs)
template<typename T, int N, size_t D0, size_t... DIMS>
constexpr NdArray< Simd< T, N >, D0, DIMS... > superdex::operator/ (T lhs, NdArray< Simd< T, N >, D0, DIMS... > const &rhs)
template<typename T, size_t D0>
constexpr bool superdex::operator== (NdArray< Simd< T, 4 >, D0 > const &lhs, NdArray< Simd< T, 4 >, D0 > const &rhs)
template<typename T>
NdArray< Simd< T, 4 >, 2 > superdex::SimdFullToSym (NdArray< Simd< T, 4 >, 3 > const &m)
template<typename T>
Simd< T, 4 > superdex::SimdFullToSym (Simd< T, 4 > const &m)
template<typename T>
NdArray< Simd< T, 4 >, 3 > superdex::SimdSymToFull (NdArray< Simd< T, 4 >, 2 > const &m)
template<typename T>
Simd< T, 4 > superdex::SimdSymToFull (Simd< T, 4 > const &m)
template<size_t D0, size_t D1, typename T>
void superdex::StoreMatrix (NdArray< T, D0, D1 > &out, NdArray< Simd< T, 4 >, D0 > const &x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T>
void superdex::StoreMatrix (NdArray< T, D0, D1, D2, D3 > &out, NdArray< Simd< T, 4 >, D0, D1, D2 > const &x)
template<size_t D0, size_t D1, typename T>
void superdex::StoreMatrix (Span< T > out, NdArray< Simd< T, 4 >, D0 > const &x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T>
void superdex::StoreMatrix (T *out, NdArray< Simd< T, 4 >, D0, D1, D2 > const &x)
template<size_t D0, size_t D1, typename T>
void superdex::StoreMatrix (T *outData, NdArray< Simd< T, 4 >, D0 > const &x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T>
void superdex::StoreSubmatrix (NdArray< T, D2, D3 > &out, Int2 coords, NdArray< Simd< T, 4 >, D0 > const &x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T>
void superdex::StoreSubmatrix (Span< T > out, Int2 coords, NdArray< Simd< T, 4 >, D0 > const &x)
template<size_t D0, size_t D1, size_t D2, size_t D3, typename T>
void superdex::StoreSubmatrix (T *out, Int2 coords, NdArray< Simd< T, 4 >, D0 > const &x)
template<int kTupleCount = -1, class V, std::enable_if_t< IsSimd< V >, superdex::ConceptMatch > = superdex::ConceptMatch::True>
void superdex::StoreTransposed (typename V::Scalar *ptr, NdArray< V, 3 > const &src)
template<typename T>
NdArray< T, 4, 4 > superdex::ToNdArray (NdArray< Simd< T, 4 >, 4 > m)
template<typename T>
NdArray< T, 2, 2 > superdex::ToNdArray2x2 (Simd< T, 4 > m)
template<typename T>
NdArray< T, 3, 3 > superdex::ToNdArray3x3 (NdArray< Simd< T, 4 >, 3 > m)
template<typename T>
NdArray< T, 2, 2 > superdex::ToNdArraySym2x2 (Simd< T, 4 > m)
template<typename T>
NdArray< T, 3, 3 > superdex::ToNdArraySym3x3 (NdArray< Simd< T, 4 >, 2 > m)
template<typename T>
NdArray< T, 3, 3, 3 > superdex::ToNdArrayTensor (NdArray< Simd< T, 4 >, 3, 3 > const &t)
template<typename T>
NdArray< T, 3, 3, 3, 3 > superdex::ToNdArrayTensor (NdArray< Simd< T, 4 >, 3, 3, 3 > const &t)
template<typename T>
Real2 superdex::ToReal2 (Simd< T, 4 > v)
template<typename T>
Real3 superdex::ToReal3 (Simd< T, 4 > v)
template<typename T>
Real4 superdex::ToReal4 (Simd< T, 4 > v)
template<typename T>
Simd< T, 4 > superdex::ToSimd (NdArray< T, 2 > const &v, T z=T(0), T w=T(0))
template<typename T>
Simd< T, 4 > superdex::ToSimd (NdArray< T, 3 > const &v, T w=T(0))
template<typename T>
Simd< T, 4 > superdex::ToSimd (NdArray< T, 4 > v)
template<typename T>
Simd< T, 4 > superdex::ToSimdFromSymComponents2x2 (T a00, T a01, T a11)
template<typename T>
Simd< T, 4 > superdex::ToSimdMatrix (NdArray< T, 2, 2 > const &m)
template<typename T>
NdArray< Simd< T, 4 >, 3 > superdex::ToSimdMatrix (NdArray< T, 3, 3 > const &m)
template<typename T>
NdArray< Simd< T, 4 >, 4 > superdex::ToSimdMatrix (NdArray< T, 4, 4 > const &m)
template<typename T>
Simd< T, 4 > superdex::ToSimdSymMatrix (NdArray< T, 2, 2 > const &m)
template<typename T>
NdArray< Simd< T, 4 >, 2 > superdex::ToSimdSymMatrix (NdArray< T, 3, 3 > const &m)
template<typename T>
NdArray< Simd< T, 4 >, 3, 3 > superdex::ToSimdTensor (NdArray< T, 3, 3, 3 > const &t)
template<typename T>
NdArray< Simd< T, 4 >, 3, 3, 3 > superdex::ToSimdTensor (NdArray< T, 3, 3, 3, 3 > const &t)

Macro Definition Documentation

◆ MOCHI_DETAILS_NDARRAY_SIMD_MEMBERWISE_OP

#define MOCHI_DETAILS_NDARRAY_SIMD_MEMBERWISE_OP ( OP_EQ,
OP )
Value:
template <typename T, int N, size_t D0, size_t... DIMS> \
MOCHI_FORCE_INLINE constexpr NdArray<Simd<T, N>, D0, DIMS...> operator OP( \
NdArray<Simd<T, N>, D0, DIMS...> const& lhs, T rhs) { \
return lhs OP Simd<T, N>(rhs); /* NdArray<Simd> OP Simd */ \
} \
template <typename T, int N, size_t D0, size_t... DIMS> \
MOCHI_FORCE_INLINE constexpr NdArray<Simd<T, N>, D0, DIMS...> operator OP( \
T lhs, NdArray<Simd<T, N>, D0, DIMS...> const& rhs) { \
NdArray<Simd<T, N>, D0, DIMS...> result{}; \
MOCHI_DETAILS_UNROLL_OP_SCALAR_ARRAY( \
result, OP, (Simd<T, N>{lhs}), rhs); /* Simd OP NdArray<Simd> */ \
return result; \
}
MOCHI_FORCE_INLINE
#define MOCHI_FORCE_INLINE
Definition mochi_platform.h:340

Definition at line 259 of file vmatrix.h.

◆ MOCHI_DETAILS_UNROLL_OP_SCALAR_ARRAY

#define MOCHI_DETAILS_UNROLL_OP_SCALAR_ARRAY ( result,
OP,
a,
b )
Value:
if constexpr (D0 <= 4) { \
(result)[0] = a OP b[0]; \
if constexpr (D0 > 1) { \
(result)[1] = a OP b[1]; \
} \
if constexpr (D0 > 2) { \
(result)[2] = a OP b[2]; \
} \
if constexpr (D0 > 3) { \
(result)[3] = a OP b[3]; \
} \
} else { \
for (size_t i = 0; i < D0; ++i) { \
(result)[i] = a OP b[i]; \
} \
}

Definition at line 240 of file vmatrix.h.