SuperDex Physics C++ API
Loading...
Searching...
No Matches
simd_inl.h File Reference
#include <mochi_core/utils/debug.h>
#include <array>
#include <cmath>
#include <cstring>
#include <limits>
#include <type_traits>
#include <utility>
#include "../simd.h"

Go to the source code of this file.

Namespaces

namespace  superdex

Macros

#define MOCHI_DEFINE_MIXED_SIMD_SCALAR_OP(OP)
#define MOCHI_DEFINE_SIMD_OP_EQ(OP_EQ, OP)
#define MOCHI_SIMD_MEMBERWISE_FALLBACK(T, N, FN, inVec)

Functions

template<class T, int N>
Simd< T, N > superdex::Abs (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::ACos (Simd< T, N > a)
template<int COUNT = -1, class T, int N>
bool superdex::AllTrue (Simd< T, N > a)
template<int COUNT = -1, class T, int N>
bool superdex::AnyTrue (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::ASin (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::ATan (Simd< T, N > a)
template<int x, int y, int z, int w, class T, int N>
Simd< T, N > superdex::Blend (Simd< T, N > a, Simd< T, N > b)
template<int x, int y, class T, int N>
Simd< T, N > superdex::Blend (Simd< T, N > a, Simd< T, N > b)
template<int i, class T, int N>
Simd< T, N > superdex::Broadcast (Simd< T, N > v)
template<class T, int N>
Simd< T, N > superdex::Broadcast (Simd< T, N > v, int i)
template<class V, std::enable_if_t< IsSimd< V >, superdex::ConceptMatch > = superdex::ConceptMatch::True>
V superdex::Broadcast (typename V::Scalar a)
template<class V, std::enable_if_t< IsSimd< V >, superdex::ConceptMatch > = superdex::ConceptMatch::True>
V superdex::Broadcast (typename V::Scalar const *ptr)
template<class T, int N>
Simd< T, N > superdex::Cos (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::Cross3 (Simd< T, N > a, Simd< T, N > b)
template<int COUNT = -1, class T, int N>
bool superdex::Equal (Simd< T, N > a, Simd< T, N > b)
template<class T, int N>
Simd< T, N > superdex::Exp (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::FastRound (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::Floor (Simd< T, N > a)
template<int i, class T, int N>
T superdex::Get (Simd< T, N > v)
template<class T, int N>
T superdex::Get (Simd< T, N > v, int i)
template<class T, int N>
T superdex::Get0 (Simd< T, N > v)
template<int iHalf, class T, int N>
Simd< T, N/2 > superdex::GetHalf (Simd< T, N > a)
template<int COUNT = -1, class T, int N>
T superdex::HMax (Simd< T, N > a)
template<int COUNT = -1, class T, int N>
T superdex::HMin (Simd< T, N > a)
template<int COUNT = -1, class T, int N>
T superdex::HProd (Simd< T, N > a)
template<int COUNT = -1, class T, int N>
T superdex::HSum (Simd< T, N > a)
template<int i, class T, int N>
int superdex::IsTrue (Simd< T, N > mask)
template<class T, int N>
Simd< T, N > superdex::Ln (Simd< T, N > a)
template<int N, class V, std::enable_if_t< IsSimd< V >, superdex::ConceptMatch > = superdex::ConceptMatch::True>
V superdex::Load (typename V::Scalar const *ptr)
template<class V, std::enable_if_t< IsSimd< V >, superdex::ConceptMatch > = superdex::ConceptMatch::True>
V superdex::Load (typename V::Scalar const *ptr)
template<class V, std::enable_if_t< IsSimd< V >, superdex::ConceptMatch > = superdex::ConceptMatch::True>
V superdex::Load (typename V::Scalar const *ptr, int n)
template<class V, class I, std::enable_if_t< IsSimd< V >, superdex::ConceptMatch > = superdex::ConceptMatch::True>
V superdex::LoadIndexed (typename V::Scalar const *ptr, Simd< I, V::kSize > indices)
template<int kTupleCount = -1, class T, int N>
void superdex::LoadTransposed (T const *ptr, Simd< T, N > &out0, Simd< T, N > &out1, Simd< T, N > &out2)
template<class T, int N>
Simd< T, N > superdex::Max (Simd< T, N > a, Simd< T, N > b)
template<class T, int N>
Simd< T, N > superdex::Min (Simd< T, N > a, Simd< T, N > b)
template<class T, int N>
Simd< T, N > superdex::MulAdd (Simd< T, N > a, Simd< T, N > b, Simd< T, N > c)
template<class T, int N>
Simd< T, N > superdex::MulSub (Simd< T, N > a, Simd< T, N > b, Simd< T, N > c)
template<bool x, bool y, bool z, bool w, class T, int N>
Simd< T, N > superdex::Neg (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::NegMulAdd (Simd< T, N > a, Simd< T, N > b, Simd< T, N > c)
template<class T, int N>
Simd< T, N > superdex::NegMulSub (Simd< T, N > a, Simd< T, N > b, Simd< T, N > c)
template<int COUNT = -1, class T, int N>
T superdex::Norm (Simd< T, N > a)
template<int COUNT = -1, class T, int N>
Simd< T, N > superdex::Normalize (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::Normalize (Simd< T, N > a, Simd< T, N > normSqr)
template<class T, int N>
Simd< T, N > superdex::Normalize (Simd< T, N > a, T normSqr)
template<int COUNT = -1, class T, int N>
T superdex::NormSqr (Simd< T, N > a)
template<int COUNT = -1, class T, int N>
bool superdex::NotEqual (Simd< T, N > a, Simd< T, N > b)
template<class T, int N>
Simd< T, N > superdex::operator&& (Simd< T, N > lhs, Simd< T, N > rhs)
template<class T, int N, class RHS>
Simd< T, N > & superdex::operator&= (Simd< T, N > &lhs, RHS rhs)
template<class T, int N>
auto superdex::operator* (Simd< T, N > lhs, T rhs)
template<class T, int N>
auto superdex::operator* (T lhs, Simd< T, N > rhs)
template<class T, int N, class RHS>
Simd< T, N > & superdex::operator*= (Simd< T, N > &lhs, RHS rhs)
template<class T, int N>
auto superdex::operator+ (Simd< T, N > lhs, T rhs)
template<class T, int N>
auto superdex::operator+ (T lhs, Simd< T, N > rhs)
template<class T, int N, class RHS>
Simd< T, N > & superdex::operator+= (Simd< T, N > &lhs, RHS rhs)
template<class T, int N>
auto superdex::operator- (Simd< T, N > lhs, T rhs)
template<class T, int N>
auto superdex::operator- (T lhs, Simd< T, N > rhs)
template<class T, int N, class RHS>
Simd< T, N > & superdex::operator-= (Simd< T, N > &lhs, RHS rhs)
template<class T, int N>
auto superdex::operator/ (Simd< T, N > lhs, T rhs)
template<class T, int N>
auto superdex::operator/ (T lhs, Simd< T, N > rhs)
template<class T, int N, class RHS>
Simd< T, N > & superdex::operator/= (Simd< T, N > &lhs, RHS rhs)
template<class T, int N, class RHS>
Simd< T, N > & superdex::operator^= (Simd< T, N > &lhs, RHS rhs)
template<class T, int N, class RHS>
Simd< T, N > & superdex::operator|= (Simd< T, N > &lhs, RHS rhs)
template<class T, int N>
Simd< T, N > superdex::operator|| (Simd< T, N > lhs, Simd< T, N > rhs)
template<class T>
Simd< T, 4 > superdex::OrthogonalVector3 (Simd< T, 4 > a)
template<class T, int N>
Simd< T, N > superdex::RcpApprox (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::RcpSqrtApprox (Simd< T, N > a)
template<class T, int N, class MaskT>
Simd< T, N > superdex::Select (Simd< MaskT, N > conditionMask, Simd< T, N > a, Simd< T, N > b)
template<class V>
V superdex::Sequence ()
template<class T, int N>
Simd< T, N > superdex::Set (Simd< T, N > a, int i, T value)
template<int i, class T, int N>
Simd< T, N > superdex::Set (Simd< T, N > a, T value)
template<int kShift, class T, int N>
Simd< T, N > superdex::ShiftRight (Simd< T, N > a)
template<int x = 0, int y = 1, class T>
Simd< T, 2 > superdex::Shuffle (Simd< T, 2 > a)
template<int x = 0, int y = 1, int z = 2, int w = 3, class T>
Simd< T, 4 > superdex::Shuffle (Simd< T, 4 > a)
template<int x, int y, int z, int w, class T>
Simd< T, 4 > superdex::Shuffle (Simd< T, 4 > a, Simd< T, 4 > b)
template<int i, class V = Vec4r>
V superdex::SimdBasisVector ()
template<class V = Vec4r>
V superdex::SimdBasisVector (int axis)
template<class V, class... MoreBools>
V superdex::SimdMask (bool b0, bool b1, MoreBools... bs)
template<class V = Vec4r>
V superdex::SimdZero ()
template<class T, int N>
Simd< T, N > superdex::Sin (Simd< T, N > a)
template<class T, int N>
std::pair< Simd< T, N >, Simd< T, N > > superdex::SinCos (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::Sqrt (Simd< T, N > a)
template<int COUNT = -1, class T, int N>
void superdex::Store (T *ptr, Simd< T, N > a)
template<class T, int N>
void superdex::Store (T *ptr, Simd< T, N > a, int count)
template<class T, int N, class MaskT>
int superdex::StoreSelected (T *ptr, Simd< MaskT, N > condition, Simd< T, N > values)
template<int kTupleCount = -1, class T, int N>
void superdex::StoreTransposed (T *ptr, Simd< T, N > a, Simd< T, N > b, Simd< T, N > c)
template<class T, int N>
Simd< T, N > superdex::Tan (Simd< T, N > a)
template<class T, int N>
Simd< T, N > superdex::Tanh (Simd< T, N > a)
template<class V>
V superdex::ToSimdDirection (V a)
template<class V>
V superdex::ToSimdPoint (V a)
template<int COUNT = -1, class V>
V superdex::VDot (V a, V b)
template<class V>
V superdex::VEqual (V a, V b)
template<class T, int N>
Simd< T, N > superdex::VIsFinite (Simd< T, N > a)
template<class V>
V superdex::VNearEqual (V a, V b, V epsilon)
template<class V>
V superdex::VNearZero (V a, V epsilon)
template<int COUNT = -1, class T, int N>
Simd< T, N > superdex::VNorm (Simd< T, N > a)
template<int COUNT = -1, class T, int N>
Simd< T, N > superdex::VNormSqr (Simd< T, N > a)
template<class V>
V superdex::VNotEqual (V a, V b)

Macro Definition Documentation

◆ MOCHI_DEFINE_MIXED_SIMD_SCALAR_OP

#define MOCHI_DEFINE_MIXED_SIMD_SCALAR_OP ( OP)
Value:
template <class T, int N> \
MOCHI_ANY MOCHI_FORCE_INLINE auto operator OP(Simd<T, N> lhs, T rhs) { \
return lhs OP Simd<T, N>{rhs}; \
} \
template <class T, int N> \
MOCHI_ANY MOCHI_FORCE_INLINE auto operator OP(T lhs, Simd<T, N> rhs) { \
return Simd<T, N>{lhs} OP rhs; \
}
MOCHI_FORCE_INLINE
#define MOCHI_FORCE_INLINE
Definition mochi_platform.h:340
MOCHI_ANY
#define MOCHI_ANY
Definition mochi_platform.h:315

Definition at line 55 of file simd_inl.h.

◆ MOCHI_DEFINE_SIMD_OP_EQ

#define MOCHI_DEFINE_SIMD_OP_EQ ( OP_EQ,
OP )
Value:
template <class T, int N, class RHS> \
MOCHI_ANY MOCHI_FORCE_INLINE Simd<T, N>& operator OP_EQ(Simd<T, N>& lhs, RHS rhs) { \
lhs = lhs OP rhs; \
return lhs; \
}

Definition at line 47 of file simd_inl.h.

◆ MOCHI_SIMD_MEMBERWISE_FALLBACK

#define MOCHI_SIMD_MEMBERWISE_FALLBACK ( T,
N,
FN,
inVec )
Value:
alignas(alignof(Simd<T, N>)) T buf[N]; \
Store(buf, inVec); \
for (int i = 0; i < N; ++i) { \
buf[i] = FN(buf[i]); \
} \
return Load<Simd<T, N>>(buf)

Definition at line 402 of file simd_inl.h.