Harlinn.Windows 0.1
|
Namespaces | |
namespace | Internal |
Concepts | |
concept | FloatingPointType |
concept | VectorType |
concept | VectorSimdType |
concept | ScalarType |
concept | ScalarSimdType |
concept | PointType |
concept | PointSimdType |
concept | NormalType |
concept | NormalSimdType |
Typedefs | |
using | Vector2f = Vector<float,2> |
using | Vector2i = Vector<int,2> |
using | Vector3f = Vector<float,3> |
using | Vector3i = Vector<int, 3> |
Enumerations | |
enum class | MatrixType : UInt32 { Zero , Identity } |
Functions | |
constexpr bool | IsSameValue (double first, double second) noexcept |
Tests whether two double precision floating point values holds the same value. This function returns true if both hold the same NaN value. | |
constexpr bool | IsSameValue (float x, float y) noexcept |
Tests whether two single precision floating point values holds the same value. This function returns true if both hold the same NaN value. | |
constexpr bool | IsZero (double x) noexcept |
Tests if a double precision floating value is zero. | |
constexpr bool | IsZero (float x) noexcept |
Tests if a double precision floating value is zero. | |
template<typename T > requires IsUnsignedInteger<std::remove_cvref_t<T>> || IsBoolean<std::remove_cvref_t<T>> | |
constexpr T | signum (T val) noexcept |
template<typename T > requires IsSignedInteger<std::remove_cvref_t<T>> | |
constexpr T | signum (T val) noexcept |
Returns the sign of a value for a signed integer type. | |
template<typename T > requires IsFloatingPoint<std::remove_cvref_t<T>> | |
constexpr T | signum (T val) noexcept |
Returns the sign of a value for a floating point type. | |
template<typename T > requires IsFloatingPoint<std::remove_cvref_t<T>> | |
constexpr std::remove_cvref_t< T > | Deg2Rad (T angleInDegrees) noexcept |
Converts an angle in degrees into the corresponding angle in radians. | |
template<typename T > requires IsFloatingPoint<std::remove_cvref_t<T>> | |
constexpr std::remove_cvref_t< T > | Rad2Deg (T angleInRadians) noexcept |
Converts an angle in radians into the corresponding angle in degrees. | |
constexpr double | NextAfter (double x, double y) noexcept |
constexpr float | NextAfter (float x, float y) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Sqrt (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | ReciprocalSqrt (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | NextDown (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | NextUp (T x) noexcept |
template<typename T > requires IsInteger<T> | |
constexpr bool | IsNaN (T val) noexcept |
IsNaN for integer types, always returns false. | |
template<typename T > requires IsFloatingPoint<T> | |
constexpr bool | IsNaN (T val) noexcept |
template<typename T > requires IsInteger<T> | |
constexpr bool | IsInf (T val) noexcept |
Integers cannot represent infinite, so this function always returns false. | |
template<typename T > requires IsFloatingPoint<T> | |
constexpr bool | IsInf (T val) noexcept |
template<typename T > requires IsSignedInteger<T> | |
constexpr std::remove_cvref_t< T > | Abs (T val) noexcept |
template<typename T > requires IsUnsignedInteger<T> | |
constexpr std::remove_cvref_t< T > | Abs (T val) noexcept |
The absolute value of any unsigned integer is the same as its value. | |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Abs (T val) noexcept |
template<typename T > requires IsSignedInteger<T> | |
constexpr bool | SignBit (T val) noexcept |
Determines if the given signed integer value is negative. | |
template<typename T > requires IsUnsignedInteger<T> | |
constexpr bool | SignBit (T val) noexcept |
An Implementation of SignBit for unsigned integers that always returns false. | |
template<typename T > requires IsFloatingPoint<T> | |
constexpr bool | SignBit (T val) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::pair< std::remove_cvref_t< T >, int > | FRExp (T val) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | FRExp (T val, int *exp) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | FRExp (T val, int &exp) noexcept |
template<typename ValueT > requires IsFloatingPoint<std::remove_cvref_t<ValueT>> | |
constexpr std::pair< std::remove_cvref_t< ValueT >, std::remove_cvref_t< ValueT > > | ModF (ValueT val) noexcept |
template<typename ValueT > requires IsFloatingPoint<std::remove_cvref_t<ValueT>> | |
constexpr std::remove_cvref_t< ValueT > | ModF (ValueT val, ValueT *integerPart) noexcept |
template<typename ValueT > requires IsFloatingPoint<std::remove_cvref_t<ValueT>> | |
constexpr std::remove_cvref_t< ValueT > | ModF (ValueT val, ValueT &integerPart) noexcept |
template<typename T > | |
constexpr std::remove_cvref_t< T > | Min (T first, T second) noexcept |
template<typename T , typename ... Args> requires IsFloatingPoint<T> || IsInteger<T> | |
constexpr T | Min (T first, T second, Args... remaining) noexcept |
template<typename T > | |
constexpr std::remove_cvref_t< T > | Max (T first, T second) noexcept |
template<typename T , typename ... Args> requires IsFloatingPoint<T> || IsInteger<T> | |
constexpr T | Max (T first, T second, Args... remaining) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Trunc (T value) noexcept |
template<typename T > requires IsInteger<T> | |
constexpr std::remove_cvref_t< T > | Trunc (T value) noexcept |
Just returns value. | |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Floor (T value) noexcept |
template<typename T > requires IsInteger<T> | |
constexpr std::remove_cvref_t< T > | Floor (T value) noexcept |
Just returns value. | |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Ceil (T value) noexcept |
template<typename T > requires IsInteger<T> | |
constexpr std::remove_cvref_t< T > | Ceil (T value) noexcept |
Just returns value. | |
template<typename T > | |
constexpr std::remove_cvref_t< T > | Round (T value) noexcept |
template<typename T > | |
constexpr T & | Clamp (const T &value, const T &minimumValue, const T &maximumValue) |
template<typename T , typename U > requires ( ( IsInteger<T> || IsFloatingPoint<T> ) && ( IsInteger<U> || IsFloatingPoint<U> ) ) | |
constexpr std::conditional_t< IsFloatingPoint< T >, T, std::conditional_t< IsFloatingPoint< U >, U, T > > | Lerp (T a, T b, U t) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | CopySign (T magnitude, T signValue) noexcept |
constexpr double | ScaleByN (double x, int n) noexcept |
constexpr float | ScaleByN (float x, int n) noexcept |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr std::remove_cvref_t< FloatT > | FMod (FloatT x, FloatT y) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Exp (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Hypot (T x, T y) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Hypot (T x, T y, T z) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Log (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Log2 (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Log10 (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Pow (T x, T y) noexcept |
Computes the value of x raised to the power y. | |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Sin (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | ASin (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Cos (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | ACos (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Tan (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | ATan (T x) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | ATan (T x, T y) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | ATan2 (T x, T y) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr void | SinCos (T x, T &sinResult, T &cosResult) noexcept |
Simultaneously compute the sine and cosine of x, where x is in radians, returning the sine in the variable referenced by sinResult, and the cosine in the variable referenced by cosResult. | |
template<typename T > requires IsFloatingPoint<T> | |
constexpr void | SinCos (T x, T *sinResult, T *cosResult) noexcept |
Simultaneously compute the sine and cosine of x, where x is in radians, returning the sine in the variable referenced by sinResult, and the cosine in the variable referenced by cosResult. | |
template<typename T > requires IsInteger<T> | |
constexpr T | FMA (T a, T b, T c) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr T | FMA (T a, T b, T c) noexcept |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | SinXOverX (FloatT x) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | ExpM1 (FloatT x) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | Sinc (FloatT x) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | WindowedSinc (FloatT x, FloatT radius, FloatT tau) |
template<typename T > requires (IsFloatingPoint<T> == false) | |
constexpr T | Mod (T a, T b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | Mod (FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | Radians (FloatT deg) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | Degrees (FloatT rad) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | SmoothStep (FloatT x, FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | SafeSqrt (FloatT x) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | Sqr (FloatT v) |
template<int n, typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | FastPow (FloatT v) |
template<typename FloatT , typename C > | |
constexpr FloatT | EvaluatePolynomial (FloatT t, C c) |
template<typename FloatT , typename C , typename... Args> | |
constexpr FloatT | EvaluatePolynomial (FloatT t, C c, Args... remaining) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | SafeASin (FloatT x) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | SafeACos (FloatT x) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | NextFloatUp (FloatT v) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | NextFloatDown (FloatT v) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | Gamma (int n) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | AddRoundUp (FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | AddRoundDown (FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | SubRoundUp (FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | SubRoundDown (FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | MulRoundUp (FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | MulRoundDown (FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | DivRoundUp (FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | DivRoundDown (FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | SqrtRoundUp (FloatT a) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | SqrtRoundDown (FloatT a) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | FMARoundUp (FloatT a, FloatT b, FloatT c) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | FMARoundDown (FloatT a, FloatT b, FloatT c) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | FastLog2 (FloatT x) |
constexpr int | Log2Int (float v) |
constexpr int | Log2Int (double v) |
constexpr int | Log2Int (UInt32 v) |
constexpr int | Log2Int (Int32 v) |
constexpr int | Log2Int (UInt64 v) |
constexpr int | Log2Int (Int64 v) |
template<typename T > requires std::is_arithmetic_v<T> | |
constexpr int | Log4Int (T v) |
constexpr float | FastExp (float x) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | Gaussian (FloatT x, FloatT mu=0, FloatT sigma=1) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | GaussianIntegral (FloatT x0, FloatT x1, FloatT mu=0, FloatT sigma=1) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | Logistic (FloatT x, FloatT s) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | LogisticCDF (FloatT x, FloatT s) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | TrimmedLogistic (FloatT x, FloatT s, FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | ErfInv (FloatT a) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | I0 (FloatT x) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr FloatT | LogI0 (FloatT x) |
template<typename Predicate > | |
constexpr size_t | FindInterval (size_t sz, const Predicate &pred) |
template<typename T > | |
constexpr bool | IsPowerOf4 (T v) |
constexpr Int32 | RoundUpPow2 (Int32 v) |
constexpr Int64 | RoundUpPow2 (Int64 v) |
template<typename T > | |
constexpr T | RoundUpPow4 (T v) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr CompensatedFloat< FloatT > | TwoProd (FloatT a, FloatT b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr CompensatedFloat< FloatT > | TwoSum (FloatT a, FloatT b) |
template<typename Ta , typename Tb , typename Tc , typename Td > requires IsFloatingPoint<Ta> && IsFloatingPoint<Tb> && IsFloatingPoint<Tc> && IsFloatingPoint<Td> | |
constexpr auto | DifferenceOfProducts (Ta a, Tb b, Tc c, Td d) |
template<typename Ta , typename Tb , typename Tc , typename Td > requires IsFloatingPoint<Ta>&& IsFloatingPoint<Tb>&& IsFloatingPoint<Tc>&& IsFloatingPoint<Td> | |
constexpr auto | SumOfProducts (Ta a, Tb b, Tc c, Td d) |
template<typename FloatT , typename... T> requires std::conjunction_v<std::is_arithmetic<T>...> | |
constexpr FloatT | InnerProduct (FloatT term, T... terms) |
template<typename FloatT , typename... T> requires IsFloatingPoint<FloatT> | |
constexpr bool | Quadratic (FloatT a, FloatT b, FloatT c, FloatT *t0, FloatT *t1) |
template<typename Func , typename FloatT > | |
constexpr FloatT | NewtonBisection (FloatT x0, FloatT x1, Func f, FloatT xEps=static_cast< FloatT >(1e-6), FloatT fEps=static_cast< FloatT >(1e-6)) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr bool | InRange (FloatT value, const Interval< FloatT > &interval) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr bool | InRange (const Interval< FloatT > &first, const Interval< FloatT > &second) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
constexpr Interval< FloatT > | Sqr (const Interval< FloatT > &interval) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | MulPow2 (FloatT s, const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | MulPow2 (const Interval< FloatT > &i, FloatT s) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | operator+ (FloatT f, const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | operator- (FloatT f, const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | operator* (FloatT f, const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | operator/ (FloatT f, const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | operator+ (const Interval< FloatT > &i, FloatT f) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | operator- (const Interval< FloatT > &i, FloatT f) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | operator* (const Interval< FloatT > &i, FloatT f) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | operator/ (const Interval< FloatT > &i, FloatT f) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
FloatT | Floor (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
FloatT | Ceil (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
FloatT | floor (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
FloatT | ceil (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
FloatT | Min (const Interval< FloatT > &a, const Interval< FloatT > &b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
FloatT | Max (const Interval< FloatT > &a, const Interval< FloatT > &b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
FloatT | min (const Interval< FloatT > &a, const Interval< FloatT > &b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
FloatT | max (const Interval< FloatT > &a, const Interval< FloatT > &b) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | Sqrt (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | sqrt (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | FMA (const Interval< FloatT > &a, const Interval< FloatT > &b, const Interval< FloatT > &c) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | DifferenceOfProducts (const Interval< FloatT > &a, const Interval< FloatT > &b, const Interval< FloatT > &c, const Interval< FloatT > &d) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | SumOfProducts (const Interval< FloatT > &a, const Interval< FloatT > &b, const Interval< FloatT > &c, const Interval< FloatT > &d) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | Abs (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | abs (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | ACos (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | Sin (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | Cos (const Interval< FloatT > &i) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
bool | Quadratic (const Interval< FloatT > &a, const Interval< FloatT > &b, const Interval< FloatT > &c, Interval< FloatT > *t0, Interval< FloatT > *t1) |
template<typename FloatT > requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | SumSquares (const Interval< FloatT > &i) |
template<typename FloatT , typename... Args> requires IsFloatingPoint<FloatT> | |
Interval< FloatT > | SumSquares (const Interval< FloatT > &i, Args... args) |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::pair< double, int > | FRExp (T val) noexcept |
template<typename T > requires IsInteger<T> | |
constexpr std::remove_cvref_t< T > | Min (T first, T second) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Min (T first, T second) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Max (T first, T second) noexcept |
template<typename T > requires IsInteger<T> | |
constexpr std::remove_cvref_t< T > | Max (T first, T second) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
constexpr std::remove_cvref_t< T > | Round (T value) noexcept |
template<typename T > requires IsInteger<T> | |
constexpr std::remove_cvref_t< T > | Round (T value) noexcept |
template<typename T > requires requires( const T& t1, const T& t2 ) { { t1 < t2 }->std::convertible_to<bool>; } | |
constexpr const T & | Clamp (const T &value, const T &minimumValue, const T &maximumValue) |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T,U> | |
T | operator+ (const T &lhs, const U &rhs) noexcept |
template<Internal::SimdType T, Internal::TupleType U> requires Internal::IsCompatible<T, U> | |
T | operator+ (const T &lhs, const U &rhs) noexcept |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | operator+ (const U &lhs, const T &rhs) noexcept |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | operator+ (const T &lhs, const U &rhs) noexcept |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | operator- (const T &lhs, const U &rhs) noexcept |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | operator- (const U &lhs, const T &rhs) noexcept |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | operator- (const T &lhs, const U &rhs) noexcept |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | operator* (const T &lhs, const U &rhs) noexcept |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | operator* (const U &lhs, const T &rhs) noexcept |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | operator* (const T &lhs, const U &rhs) noexcept |
template<Internal::SimdType T, typename U > requires std::is_arithmetic_v<U> | |
T | operator* (const T &lhs, const U rhs) noexcept |
template<typename U , Internal::SimdType T> requires std::is_arithmetic_v<U> | |
T | operator* (const U lhs, const T &rhs) noexcept |
template<Internal::TupleType T, typename U , typename ResultT = typename T::Simd> requires std::is_arithmetic_v<U> | |
ResultT | operator* (const T &lhs, const U rhs) noexcept |
template<typename U , Internal::TupleType T, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<U> | |
ResultT | operator* (const U lhs, const T &rhs) noexcept |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | operator/ (const T &lhs, const U &rhs) noexcept |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | operator/ (const U &lhs, const T &rhs) noexcept |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | operator/ (const T &lhs, const U &rhs) noexcept |
template<Internal::SimdType T, typename U > requires std::is_arithmetic_v<U> | |
T | operator/ (const T &lhs, const U rhs) noexcept |
template<typename U , Internal::SimdType T> requires std::is_arithmetic_v<U> | |
T | operator/ (const U lhs, const T &rhs) noexcept |
template<Internal::TupleType T, typename U , typename ResultT = typename T::Simd> requires std::is_arithmetic_v<U> | |
ResultT | operator/ (const T &lhs, const U rhs) noexcept |
template<typename U , Internal::TupleType T, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<U> | |
ResultT | operator/ (const U lhs, const T &rhs) noexcept |
template<Internal::SimdType T> | |
auto | First (const T &v) |
Retrieves the lowest element of v. | |
template<Internal::SimdType T> | |
T | HSum (const T &t) noexcept |
Calculates the horizontal sum of the elements in the vector. | |
template<Internal::TupleType T, typename ResultT = typename T::value_type> | |
ResultT | ScalarHSum (const T &t) noexcept |
Calculates the horizontal sum of the elements in the vector. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | HSum (const T &t) noexcept |
Calculates the horizontal sum of the elements in the vector. | |
template<Internal::SimdType T> | |
T | HProd (const T &t) noexcept |
Calculates the horizontal product of the elements in the vector. | |
template<Internal::SimdType T> | |
auto | ScalarHProd (const T &t) noexcept |
template<Internal::TupleType T, typename ResultT = typename T::value_type> | |
ResultT | ScalarHProd (const T &t) noexcept |
Calculates the horizontal product of the elements in the vector. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | HProd (const T &t) noexcept |
Calculates the horizontal product of the elements in the vector. | |
template<Internal::SimdType T> | |
T | Abs (const T &t) noexcept |
Computes the absolute value of each element held by the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Abs (const T &t) noexcept |
Computes the absolute value of each element held by the argument. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | Min (const T &lhs, const U &rhs) noexcept |
Makes a comparison between the elements held by the two arguments, and returns a TupleSimd containing the smallest elements. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | Min (const U &lhs, const T &rhs) noexcept |
Makes a comparison between the elements held by the two arguments, and returns a TupleSimd containing the smallest elements. | |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | Min (const T &lhs, const U &rhs) noexcept |
Makes a comparison between the elements held by the two arguments, and returns a TupleSimd containing the smallest elements. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | Max (const T &lhs, const U &rhs) noexcept |
Makes a comparison between the elements held by the two arguments, and returns a TupleSimd containing the largest elements. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | Max (const U &lhs, const T &rhs) noexcept |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | Max (const T &lhs, const U &rhs) noexcept |
template<Internal::SimdType T> | |
T | Sqr (const T &t) noexcept |
Computes the square value of each element held by the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Sqr (const T &t) noexcept |
Computes the square value of each element held by the argument. | |
template<Internal::SimdType T> | |
T | Ceil (const T &t) noexcept |
Computes the ceiling of each element held by the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Ceil (const T &t) noexcept |
Computes the ceiling of each element held by the argument. | |
template<Internal::SimdType T> | |
T | Floor (const T &t) noexcept |
Computes the floor of each element held by the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Floor (const T &t) noexcept |
Computes the floor of each element held by the argument. | |
template<Internal::SimdType T> | |
T | Round (const T &t) noexcept |
Rounds each element held by the argument towards the nearest even integer. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Round (const T &t) noexcept |
Rounds each element held by the argument towards the nearest even integer. | |
template<Internal::SimdType T> | |
T | Trunc (const T &t) noexcept |
Rounds each element held by the argument to the nearest integer in the direction of zero. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Trunc (const T &t) noexcept |
Rounds each element held by the argument to the nearest integer in the direction of zero. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT> && Internal::IsCompatible<T, U> | |
T | Lerp (NumberT a, const T &b, const U &c) noexcept |
Calculates the linear interpolation between the the elements of a and the elements of b, for elements of c is inside [0,1), or the linear extrapolation for elements in c outside [0,1). | |
template<typename NumberT , Internal::SimdType T, Internal::TupleType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | Lerp (NumberT a, const T &b, const U &c) noexcept |
Calculates the linear interpolation between the the elements of a and the elements of b, for elements of c is inside [0,1), or the linear extrapolation for elements in c outside [0,1). | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | Lerp (NumberT a, const T &b, const U &c) noexcept |
Calculates the linear interpolation between the the elements of a and the elements of b, for elements of c is inside [0,1), or the linear extrapolation for elements in c outside [0,1). | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | Lerp (NumberT a, const T &b, const U &c) noexcept |
Calculates the linear interpolation between the the elements of a and the elements of b, for elements of c is inside [0,1), or the linear extrapolation for elements in c outside [0,1). | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
T | Lerp (const S &a, const T &b, const U &c) noexcept |
Calculates the linear interpolation between the the elements of a and the elements of b, for elements of c is inside [0,1), or the linear extrapolation for elements in c outside [0,1). | |
template<Internal::SimdType S, Internal::TupleType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
U | Lerp (const S &a, const T &b, const U &c) noexcept |
Calculates the linear interpolation between the the elements of a and the elements of b, for elements of c is inside [0,1), or the linear extrapolation for elements in c outside [0,1). | |
template<Internal::SimdType S, Internal::TupleType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
S | Lerp (const S &a, const T &b, const U &c) noexcept |
Calculates the linear interpolation between the the elements of a and the elements of b, for elements of c is inside [0,1), or the linear extrapolation for elements in c outside [0,1). | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
ResultT | Lerp (const S &a, const T &b, const U &c) noexcept |
Calculates the linear interpolation between the the elements of a and the elements of b, for elements of c is inside [0,1), or the linear extrapolation for elements in c outside [0,1). | |
template<Internal::SimdType S, Internal::SimdType T, typename U > requires Internal::IsCompatible<S, T>&& std::is_arithmetic_v<U> | |
S | Lerp (const S &a, const T &b, const U c) noexcept |
Calculates the linear interpolation between the the elements of a and the elements of b, for elements of c is inside [0,1), or the linear extrapolation for elements in c outside [0,1). | |
template<Internal::TupleType S, Internal::SimdType T, typename U > requires Internal::IsCompatible<S, T>&& std::is_arithmetic_v<U> | |
S::Simd | Lerp (const S &a, const T &b, const U c) noexcept |
Calculates the linear interpolation between the the elements of a and the elements of b, for elements of c is inside [0,1), or the linear extrapolation for elements in c outside [0,1). | |
template<int shuffleMask, Internal::SimdType T> | |
T | Permute (const T &t) noexcept |
template<int shuffleMask, Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Permute (const T &t) noexcept |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
T | Clamp (const S &v, const T &lowerBounds, const U &upperBounds) noexcept |
Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
U | Clamp (const S &v, const T &lowerBounds, const U &upperBounds) noexcept |
Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
S | Clamp (const S &v, const T &lowerBounds, const U &upperBounds) noexcept |
Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, typename ResultT = typename S::Simd> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
ResultT | Clamp (const S &v, const T &lowerBounds, const U &upperBounds) noexcept |
Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT> && Internal::IsCompatible<T, U> | |
ResultT | Clamp (NumberT v, const T &lowerBounds, const U &upperBounds) noexcept |
Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned. | |
template<Internal::SimdType S, Internal::SimdType T> requires Internal::IsCompatible<S, T> | |
S | InBounds (const S &v, const T &bounds) noexcept |
Detects if the elements of a vector are within bounds. | |
template<Internal::TupleType S, Internal::SimdType T> requires Internal::IsCompatible<S, T> | |
T | InBounds (const S &v, const T &bounds) noexcept |
Detects if the elements of a vector are within bounds. | |
template<Internal::TupleType S, Internal::TupleType T> requires Internal::IsCompatible<S, T> | |
S::Simd | InBounds (const S &v, const T &bounds) noexcept |
Detects if the elements of a vector are within bounds. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T> && Internal::IsCompatible<S, U> | |
S | ClampLength (const S &v, const T &lengthMin, const U &lengthMax) noexcept |
Clamps the length of a vector to a given range. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U> | |
S | ClampLength (const S &v, const T &lengthMin, const U &lengthMax) noexcept |
Clamps the length of a vector to a given range. | |
template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U> | |
S::Simd | ClampLength (const S &v, const T &lengthMin, const U &lengthMax) noexcept |
Clamps the length of a vector to a given range. | |
template<Internal::SimdType S, typename T , typename U > requires IsFloatingPoint<T> && IsFloatingPoint<U> | |
S | ClampLength (const S &v, const T lengthMin, const U lengthMax) noexcept |
Clamps the length of a vector to a given range. | |
template<Internal::TupleType S, typename T , typename U > requires IsFloatingPoint<T>&& IsFloatingPoint<U> | |
S | ClampLength (const S &v, const T lengthMin, const U lengthMax) noexcept |
Clamps the length of a vector to a given range. | |
template<Internal::SimdType S, Internal::SimdType T> requires Internal::IsCompatible<S, T> | |
S | Reflect (const S &incident, const T &normal) noexcept |
Reflects an incident vector across a normal vector. | |
template<Internal::TupleType S, Internal::SimdType T> requires Internal::IsCompatible<S, T> | |
T | Reflect (const S &incident, const T &normal) noexcept |
Reflects an incident vector across a normal vector. | |
template<Internal::TupleType S, Internal::TupleType T> requires Internal::IsCompatible<S, T> | |
S::Simd | Reflect (const S &incident, const T &normal) noexcept |
Reflects an incident vector across a normal vector. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T> && Internal::IsCompatible<S, U> | |
S | Refract (const S &incident, const T &normal, const U &refractionIndex) noexcept |
Refracts an incident vector across a normal vector. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U> | |
S | Refract (const S &incident, const T &normal, const U &refractionIndex) noexcept |
Refracts an incident vector across a normal vector. | |
template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U> | |
S::Simd | Refract (const S &incident, const T &normal, const U &refractionIndex) noexcept |
Refracts an incident vector across a normal vector. | |
template<Internal::SimdType S, Internal::SimdType T, typename U > requires Internal::IsCompatible<S, T>&& IsFloatingPoint<U> | |
S | Refract (const S &incident, const T &normal, const U refractionIndex) noexcept |
Refracts an incident vector across a normal vector. | |
template<Internal::TupleType S, Internal::SimdType T, typename U > requires Internal::IsCompatible<S, T>&& IsFloatingPoint<U> | |
S::Simd | Refract (const S &incident, const T &normal, const U refractionIndex) noexcept |
Refracts an incident vector across a normal vector. | |
template<Internal::SimdType S> | |
S | Orthogonal (const S &v) noexcept |
Computes a vector perpendicular to the argument vector. | |
template<Internal::TupleType S> | |
S::Simd | Orthogonal (const S &v) noexcept |
Computes a vector perpendicular to the argument vector. | |
template<Internal::SimdType T> | |
T | Saturate (const T &v) noexcept |
Saturates the elements of v to the range 0.0 to 1.0. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Saturate (const T &v) noexcept |
Saturates the elements of v to the range 0.0 to 1.0. | |
template<Internal::SimdType T> | |
T | Sqrt (const T &v) noexcept |
Calculates the square root of each element in the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Sqrt (const T &v) noexcept |
Calculates the square root of each element in the argument. | |
template<Internal::SimdType T> | |
T | ReciprocalSqrt (const T &t) noexcept |
Calculates the reciprocal square root of each element in the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | ReciprocalSqrt (const T &t) noexcept |
Calculates the reciprocal square root of each element in the argument. | |
template<Internal::SimdType T> | |
T | Reciprocal (const T &t) noexcept |
Calculates the reciprocal of each element in the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Reciprocal (const T &t) noexcept |
Calculates the reciprocal of each element in the argument. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FMA (NumberT a, const T &b, const U &c) noexcept |
Multiplies the corresponding elements of a and b, adding the result to the corresponding element of c. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FMA (NumberT a, const T &b, const U &c) noexcept |
Multiplies the corresponding elements of a and b, adding the result to the corresponding element of c. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FMA (NumberT a, const T &b, const U &c) noexcept |
Multiplies the corresponding elements of a and b, adding the result to the corresponding element of c. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FMA (const T &a, NumberT b, const U &c) noexcept |
Multiplies the corresponding elements of a and b, adding the result to the corresponding element of c. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FMA (const T &a, NumberT b, const U &c) noexcept |
Multiplies the corresponding elements of a and b, adding the result to the corresponding element of c. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FMA (const T &a, NumberT b, const U &c) noexcept |
Multiplies the corresponding elements of a and b, adding the result to the corresponding element of c. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
T | FMA (const S &a, const T &b, const U &c) noexcept |
Multiplies the corresponding elements of a and b, adding the result to the corresponding element of c. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
U | FMA (const S &a, const T &b, const U &c) noexcept |
Multiplies the corresponding elements of a and b, adding the result to the corresponding element of c. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
S | FMA (const S &a, const T &b, const U &c) noexcept |
Multiplies the corresponding elements of a and b, adding the result to the corresponding element of c. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
ResultT | FMA (const S &a, const T &b, const U &c) noexcept |
Multiplies the corresponding elements of a and b, adding the result to the corresponding element of c. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FMSub (NumberT a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the infinite precision intermediate results are obtained. From the infinite precision intermediate results, the values in the third operand, c, are subtracted. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FMSub (NumberT a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the infinite precision intermediate results are obtained. From the infinite precision intermediate results, the values in the third operand, c, are subtracted. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FMSub (NumberT a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the infinite precision intermediate results are obtained. From the infinite precision intermediate results, the values in the third operand, c, are subtracted. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FMSub (const T &a, NumberT b, const U &c) noexcept |
Performs a set of multiply-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the infinite precision intermediate results are obtained. From the infinite precision intermediate results, the values in the third operand, c, are subtracted. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FMSub (const T &a, NumberT b, const U &c) noexcept |
Performs a set of multiply-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the infinite precision intermediate results are obtained. From the infinite precision intermediate results, the values in the third operand, c, are subtracted. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FMSub (const T &a, NumberT b, const U &c) noexcept |
Performs a set of multiply-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the infinite precision intermediate results are obtained. From the infinite precision intermediate results, the values in the third operand, c, are subtracted. The final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
T | FMSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the infinite precision intermediate results are obtained. From the infinite precision intermediate results, the values in the third operand, c, are subtracted. The final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
U | FMSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the infinite precision intermediate results are obtained. From the infinite precision intermediate results, the values in the third operand, c, are subtracted. The final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
S | FMSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the infinite precision intermediate results are obtained. From the infinite precision intermediate results, the values in the third operand, c, are subtracted. The final results are rounded to the nearest floating point values. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
ResultT | FMSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the infinite precision intermediate results are obtained. From the infinite precision intermediate results, the values in the third operand, c, are subtracted. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FMAddSub (NumberT a, const T &b, const U &c) noexcept |
Performs a set of multiply-add-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are added to the intermediate results while the even values are subtracted from them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FMAddSub (NumberT a, const T &b, const U &c) noexcept |
Performs a set of multiply-add-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are added to the intermediate results while the even values are subtracted from them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FMAddSub (NumberT a, const T &b, const U &c) noexcept |
Performs a set of multiply-add-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are added to the intermediate results while the even values are subtracted from them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FMAddSub (const T &a, NumberT b, const U &c) noexcept |
Performs a set of multiply-add-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are added to the intermediate results while the even values are subtracted from them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FMAddSub (const T &a, NumberT b, const U &c) noexcept |
Performs a set of multiply-add-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are added to the intermediate results while the even values are subtracted from them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FMAddSub (const T &a, NumberT b, const U &c) noexcept |
Performs a set of multiply-add-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are added to the intermediate results while the even values are subtracted from them. The final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
T | FMAddSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-add-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are added to the intermediate results while the even values are subtracted from them. The final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
U | FMAddSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-add-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are added to the intermediate results while the even values are subtracted from them. The final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
S | FMAddSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-add-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are added to the intermediate results while the even values are subtracted from them. The final results are rounded to the nearest floating point values. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
ResultT | FMAddSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-add-subtract computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are added to the intermediate results while the even values are subtracted from them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FMSubAdd (NumberT a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are subtracted from the intermediate results while the even values are added to them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FMSubAdd (NumberT a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are subtracted from the intermediate results while the even values are added to them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FMSubAdd (NumberT a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are subtracted from the intermediate results while the even values are added to them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FMSubAdd (const T &a, NumberT b, const U &c) noexcept |
Performs a set of multiply-subtract-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are subtracted from the intermediate results while the even values are added to them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FMSubAdd (const T &a, NumberT b, const U &c) noexcept |
Performs a set of multiply-subtract-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are subtracted from the intermediate results while the even values are added to them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FMSubAdd (const T &a, NumberT b, const U &c) noexcept |
Performs a set of multiply-subtract-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are subtracted from the intermediate results while the even values are added to them. The final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
T | FMSubAdd (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are subtracted from the intermediate results while the even values are added to them. The final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
U | FMSubAdd (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are subtracted from the intermediate results while the even values are added to them. The final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
S | FMSubAdd (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are subtracted from the intermediate results while the even values are added to them. The final results are rounded to the nearest floating point values. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
ResultT | FMSubAdd (const S &a, const T &b, const U &c) noexcept |
Performs a set of multiply-subtract-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and infinite precision intermediate results are obtained. The odd values in the third operand, c, are subtracted from the intermediate results while the even values are added to them. The final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FNMAdd (NumberT a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the negated infinite precision intermediate results are added to the values in the third operand, c, after which the final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FNMAdd (NumberT a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the negated infinite precision intermediate results are added to the values in the third operand, c, after which the final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FNMAdd (NumberT a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the negated infinite precision intermediate results are added to the values in the third operand, c, after which the final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FNMAdd (const T &a, NumberT b, const U &c) noexcept |
Performs a set of negated multiply-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the negated infinite precision intermediate results are added to the values in the third operand, c, after which the final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FNMAdd (const T &a, NumberT b, const U &c) noexcept |
Performs a set of negated multiply-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the negated infinite precision intermediate results are added to the values in the third operand, c, after which the final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FNMAdd (const T &a, NumberT b, const U &c) noexcept |
Performs a set of negated multiply-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the negated infinite precision intermediate results are added to the values in the third operand, c, after which the final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
T | FNMAdd (const S &a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the negated infinite precision intermediate results are added to the values in the third operand, c, after which the final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
U | FNMAdd (const S &a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the negated infinite precision intermediate results are added to the values in the third operand, c, after which the final results are rounded to the nearest floating point values. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
S | FNMAdd (const S &a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the negated infinite precision intermediate results are added to the values in the third operand, c, after which the final results are rounded to the nearest floating point values. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
ResultT | FNMAdd (const S &a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-add computation on a, b, and c. Corresponding values in two operands, a and b, are multiplied and the negated infinite precision intermediate results are added to the values in the third operand, c, after which the final results are rounded to the nearest floating point values. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FNMSub (NumberT a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-subtract computation on a, b, and c. The values in two operands, a and b, are multiplied and the negated infinite precision intermediate result is obtained. From this negated intermediate result, the value in the third operand, c, is subtracted. The final result is rounded to the nearest floating point value. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FNMSub (NumberT a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-subtract computation on a, b, and c. The values in two operands, a and b, are multiplied and the negated infinite precision intermediate result is obtained. From this negated intermediate result, the value in the third operand, c, is subtracted. The final result is rounded to the nearest floating point value. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FNMSub (NumberT a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-subtract computation on a, b, and c. The values in two operands, a and b, are multiplied and the negated infinite precision intermediate result is obtained. From this negated intermediate result, the value in the third operand, c, is subtracted. The final result is rounded to the nearest floating point value. | |
template<typename NumberT , Internal::SimdType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
T | FNMSub (const T &a, NumberT b, const U &c) noexcept |
Performs a set of negated multiply-subtract computation on a, b, and c. The values in two operands, a and b, are multiplied and the negated infinite precision intermediate result is obtained. From this negated intermediate result, the value in the third operand, c, is subtracted. The final result is rounded to the nearest floating point value. | |
template<typename NumberT , Internal::TupleType T, Internal::SimdType U> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
U | FNMSub (const T &a, NumberT b, const U &c) noexcept |
Performs a set of negated multiply-subtract computation on a, b, and c. The values in two operands, a and b, are multiplied and the negated infinite precision intermediate result is obtained. From this negated intermediate result, the value in the third operand, c, is subtracted. The final result is rounded to the nearest floating point value. | |
template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires std::is_arithmetic_v<NumberT>&& Internal::IsCompatible<T, U> | |
ResultT | FNMSub (const T &a, NumberT b, const U &c) noexcept |
Performs a set of negated multiply-subtract computation on a, b, and c. The values in two operands, a and b, are multiplied and the negated infinite precision intermediate result is obtained. From this negated intermediate result, the value in the third operand, c, is subtracted. The final result is rounded to the nearest floating point value. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
T | FNMSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-subtract computation on a, b, and c. The values in two operands, a and b, are multiplied and the negated infinite precision intermediate result is obtained. From this negated intermediate result, the value in the third operand, c, is subtracted. The final result is rounded to the nearest floating point value. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
U | FNMSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-subtract computation on a, b, and c. The values in two operands, a and b, are multiplied and the negated infinite precision intermediate result is obtained. From this negated intermediate result, the value in the third operand, c, is subtracted. The final result is rounded to the nearest floating point value. | |
template<Internal::SimdType S, Internal::TupleType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
S | FNMSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-subtract computation on a, b, and c. The values in two operands, a and b, are multiplied and the negated infinite precision intermediate result is obtained. From this negated intermediate result, the value in the third operand, c, is subtracted. The final result is rounded to the nearest floating point value. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U> | |
ResultT | FNMSub (const S &a, const T &b, const U &c) noexcept |
Performs a set of negated multiply-subtract computation on a, b, and c. The values in two operands, a and b, are multiplied and the negated infinite precision intermediate result is obtained. From this negated intermediate result, the value in the third operand, c, is subtracted. The final result is rounded to the nearest floating point value. | |
template<Internal::SimdType T> | |
T | Sin (const T &v) noexcept |
Calculates the sine of each element in the argument expressed in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Sin (const T &v) noexcept |
Calculates the sine of each element in the argument expressed in radians. | |
template<Internal::SimdType T> | |
T | Cos (const T &v) noexcept |
Calculates the cosine of each element in the argument expressed in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Cos (const T &v) noexcept |
Calculates the cosine of each element in the argument expressed in radians. | |
template<Internal::SimdType T> | |
T | Tan (const T &v) noexcept |
Calculates the tangent of each element in the argument expressed in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Tan (const T &v) noexcept |
Calculates the tangent of each element in the argument expressed in radians. | |
template<Internal::SimdType T> | |
T | ASin (const T &v) noexcept |
Calculates the inverse sine of each element in the argument, in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | ASin (const T &v) noexcept |
Calculates the inverse sine of each element in the argument, in radians. | |
template<Internal::SimdType T> | |
T | ACos (const T &v) noexcept |
Calculates the inverse cosine of each element in the argument, in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | ACos (const T &v) noexcept |
Calculates the inverse cosine of each element in the argument, in radians. | |
template<Internal::SimdType T> | |
T | ATan (const T &v) noexcept |
Calculates the inverse tangent of each element in the argument, in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | ATan (const T &v) noexcept |
Calculates the inverse tangent of each element in the argument, in radians. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | ATan2 (const T &x, const U &y) noexcept |
Calculates the inverse tangent of each element in x divided by the corresponding element in y, in radians. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | ATan2 (const U &x, const T &y) noexcept |
Calculates the inverse tangent of each element in x divided by the corresponding element in y, in radians. | |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | ATan2 (const T &x, const U &y) noexcept |
Calculates the inverse tangent of each element in x divided by the corresponding element in y, in radians. | |
template<Internal::SimdType T> | |
T | ModAngles (const T &angles) |
Calculates the angle modulo 2PI. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | ModAngles (const T &v) noexcept |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | AddAngles (const T &v1, const U &v2) noexcept |
Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI) | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | AddAngles (const U &v1, const T &v2) noexcept |
Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI) | |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | AddAngles (const T &v1, const U &v2) noexcept |
Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI) | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | SubtractAngles (const T &v1, const U &v2) noexcept |
Subtracts the angles in v2 from the corresponding elements of v1. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI) | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | SubtractAngles (const U &v1, const T &v2) noexcept |
Subtracts the angles in v2 from the corresponding elements of v1. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI) | |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | SubtractAngles (const T &v1, const U &v2) noexcept |
Subtracts the angles in v2 from the corresponding elements of v1. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI) | |
template<Internal::SimdType T> | |
T | SinH (const T &v) noexcept |
Calculates the hyperbolic sine of each element in the argument expressed in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | SinH (const T &v) noexcept |
Calculates the hyperbolic sine of each element in the argument expressed in radians. | |
template<Internal::SimdType T> | |
T | CosH (const T &v) noexcept |
Calculates the hyperbolic cosine of each element in the argument expressed in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | CosH (const T &v) noexcept |
Calculates the hyperbolic cosine of each element in the argument expressed in radians. | |
template<Internal::SimdType T> | |
T | TanH (const T &v) noexcept |
Calculates the hyperbolic tangent of each element in the argument expressed in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | TanH (const T &v) noexcept |
Calculates the hyperbolic tangent of each element in the argument expressed in radians. | |
template<Internal::SimdType T> | |
T | ASinH (const T &v) noexcept |
Calculates the inverse hyperbolic sine of each element in the argument, in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | ASinH (const T &v) noexcept |
Calculates the inverse hyperbolic sine of each element in the argument, in radians. | |
template<Internal::SimdType T> | |
T | ACosH (const T &v) noexcept |
Calculates the inverse hyperbolic cosine of each element in the argument, in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | ACosH (const T &v) noexcept |
Calculates the inverse hyperbolic cosine of each element in the argument, in radians. | |
template<Internal::SimdType T> | |
T | ATanH (const T &v) noexcept |
Calculates the inverse hyperbolic tangent of each element in the argument, in radians. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | ATanH (const T &v) noexcept |
Calculates the inverse hyperbolic tangent of each element in the argument, in radians. | |
template<Internal::SimdType T> | |
T | Log (const T &v) noexcept |
Calculates the natural logarithm of each element in the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Log (const T &v) noexcept |
Calculates the natural logarithm of each element in the argument. | |
template<Internal::SimdType T> | |
T | Log1P (const T &v) noexcept |
Calculates the natural logarithm of 1 + each element in the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Log1P (const T &v) noexcept |
template<Internal::SimdType T> | |
T | Log10 (const T &v) noexcept |
Calculates the base-10 logarithm of each element in the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Log10 (const T &v) noexcept |
Calculates the base-10 logarithm of each element in the argument. | |
template<Internal::SimdType T> | |
T | Log2 (const T &v) noexcept |
Calculates the base-2 logarithm, $$log_{2}_$$, of each element in the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Log2 (const T &v) noexcept |
Calculates the base-2 logarithm, $$log_{2}_$$, of each element in the argument. | |
template<Internal::SimdType T> | |
T | Exp (const T &v) noexcept |
Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Exp (const T &v) noexcept |
Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument. | |
template<Internal::SimdType T> | |
T | Exp10 (const T &v) noexcept |
Calculates the base-10 exponential of each element in the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Exp10 (const T &v) noexcept |
Calculates the base-10 exponential of each element in the argument. | |
template<Internal::SimdType T> | |
T | Exp2 (const T &v) noexcept |
Calculates the base-2 exponential of each element in the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Exp2 (const T &v) noexcept |
Calculates the base-2 exponential of each element in the argument. | |
template<Internal::SimdType T> | |
T | ExpM1 (const T &v) noexcept |
Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument, $$-1.0$$. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | ExpM1 (const T &v) noexcept |
Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument, $$-1.0$$. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | Pow (const T &base, const U &exponent) noexcept |
Calculates the elements in base raised to the corresponding element in exponent. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | Pow (const U &base, const T &exponent) noexcept |
Calculates the elements in base raised to the corresponding element in exponent. | |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | Pow (const T &base, const U &exponent) noexcept |
Calculates the elements in base raised to the corresponding element in exponent. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | Hypot (const T &x, const U &y) noexcept |
Calculates the square root of the sum of the squares of each corresponding element in x and y, without undue overflow or underflow at intermediate stages of the computation. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | Hypot (const U &x, const T &y) noexcept |
Calculates the square root of the sum of the squares of each corresponding element in x and y, without undue overflow or underflow at intermediate stages of the computation. | |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | Hypot (const T &x, const U &y) noexcept |
Calculates the square root of the sum of the squares of each corresponding element in x and y, without undue overflow or underflow at intermediate stages of the computation. | |
template<Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::SimdType W> requires Internal::IsCompatible<T, U> && Internal::IsCompatible<T, V> && Internal::IsCompatible<T, W> | |
T | Hermite (const T &firstPosition, const U &firstTangent, const V &secondPosition, const W &secondTangent, typename T::value_type t) noexcept |
Calculates the Hermite spline interpolation, using the specified arguments. | |
template<Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::TupleType W> requires Internal::IsCompatible<T, U>&& Internal::IsCompatible<T, V>&& Internal::IsCompatible<T, W> | |
T | Hermite (const T &firstPosition, const U &firstTangent, const V &secondPosition, const W &secondTangent, typename T::value_type t) noexcept |
Calculates the Hermite spline interpolation, using the specified arguments. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | Dot (const T &v1, const U &v2) noexcept |
Calculates the dot product between v1 and v2. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | Dot (const U &v1, const T &v2) noexcept |
Calculates the dot product between v1 and v2. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
constexpr T::value_type | ScalarDot (const T &v1, const U &v2) noexcept |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::value_type> requires Internal::IsCompatible<T, U> | |
constexpr ResultT | ScalarDot (const T &v1, const U &v2) noexcept |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | Dot (const T &v1, const U &v2) noexcept |
Calculates the dot product between v1 and v2. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | AbsDot (const T &v1, const U &v2) noexcept |
Calculates the absolute value of the dot product between v1 and v2. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | AbsDot (const U &v1, const T &v2) noexcept |
Calculates the absolute value of the dot product between v1 and v2. | |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | AbsDot (const T &v1, const U &v2) noexcept |
Calculates the absolute value of the dot product between v1 and v2. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
auto | ScalarAbsDot (const T &v1, const U &v2) noexcept |
Calculates the absolute value of the dot product between v1 and v2. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
auto | ScalarAbsDot (const U &v1, const T &v2) noexcept |
Calculates the absolute value of the dot product between v1 and v2. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | Cross (const T &v1, const U &v2) noexcept |
Calculates the cross product between v1 and v2. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | Cross (const U &v1, const T &v2) noexcept |
Calculates the cross product between v1 and v2. | |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | Cross (const T &v1, const U &v2) noexcept |
Calculates the cross product between v1 and v2. | |
template<Internal::SimdType T> | |
T | LengthSquared (const T &v) noexcept |
Calculates the squared length of v. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | LengthSquared (const T &v) noexcept |
Calculates the squared length of v. | |
template<Internal::SimdType T> | |
auto | ScalarLengthSquared (const T &v) noexcept |
Calculates the squared length of v. | |
template<Internal::SimdType T> | |
T | Length (const T &v) noexcept |
Calculates the length of v. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Length (const T &v) noexcept |
Calculates the length of v. | |
template<Internal::SimdType T> | |
auto | ScalarLength (const T &v) noexcept |
Calculates the length of v. | |
template<Internal::SimdType T> | |
T | Normalize (const T &v) noexcept |
Normalizes v. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | Normalize (const T &v) noexcept |
Normalizes v. | |
template<Internal::SimdType T> | |
T | ReciprocalLength (const T &v) noexcept |
Calculates the reciprocal length of v. | |
template<Internal::TupleType T, typename ResultT = typename T::Simd> | |
ResultT | ReciprocalLength (const T &v) noexcept |
Calculates the reciprocal length of v. | |
template<Internal::SimdType T> | |
auto | ScalarReciprocalLength (const T &v) noexcept |
Calculates the squared length of v. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | DistanceSquared (const T &p1, const U &p2) noexcept |
Calculates the squared distance between p1 and p2. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | DistanceSquared (const U &p1, const T &p2) noexcept |
Calculates the squared distance between p1 and p2. | |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | DistanceSquared (const T &p1, const U &p2) noexcept |
Calculates the squared distance between p1 and p2. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
auto | ScalarDistanceSquared (const T &p1, const U &p2) noexcept |
Calculates the squared distance between p1 and p2. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
auto | ScalarDistanceSquared (const U &p1, const T &p2) noexcept |
Calculates the squared distance between p1 and p2. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
T | Distance (const T &p1, const U &p2) noexcept |
Calculates the distance between p1 and p2. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
T | Distance (const U &p1, const T &p2) noexcept |
Calculates the distance between p1 and p2. | |
template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd> requires Internal::IsCompatible<T, U> | |
ResultT | Distance (const T &p1, const U &p2) noexcept |
Calculates the distance between p1 and p2. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
auto | ScalarDistance (const T &p1, const U &p2) noexcept |
Calculates the distance between p1 and p2. | |
template<Internal::TupleType U, Internal::SimdType T> requires Internal::IsCompatible<T, U> | |
auto | ScalarDistance (const U &p1, const T &p2) noexcept |
Calculates the distance between p1 and p2. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V> requires Internal::IsCompatible<S, T> && Internal::IsCompatible<S, U> && Internal::IsCompatible<S, V> | |
T | DifferenceOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::TupleType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V> | |
S | DifferenceOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U, Internal::TupleType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V> | |
T | DifferenceOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::SimdType U, Internal::SimdType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V> | |
U | DifferenceOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, Internal::SimdType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V> | |
V | DifferenceOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, Internal::TupleType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V> | |
S::Simd | DifferenceOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U> | |
T | SumOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the sum of the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::TupleType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V> | |
S | SumOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the sum of the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U, Internal::TupleType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V> | |
T | SumOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the sum of the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::SimdType U, Internal::SimdType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V> | |
U | SumOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the sum of the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, Internal::SimdType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V> | |
V | SumOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the sum of the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, Internal::TupleType V> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V> | |
S::Simd | SumOfProducts (const S &v1, const T &v2, const U &v3, const V &v4) noexcept |
Calculates the sum of the product of the first and the second argument, and the product of the third and fourth argument. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::SimdType W> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U> && Internal::IsCompatible<S, V>&& Internal::IsCompatible<S, W> | |
S | BaryCentric (const S &p1, const T &p2, const U &p3, const V &f, const W &g) noexcept |
Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::TupleType W> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& Internal::IsCompatible<S, W> | |
S | BaryCentric (const S &p1, const T &p2, const U &p3, const V &f, const W &g) noexcept |
Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system. | |
template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::SimdType W> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& Internal::IsCompatible<S, W> | |
S::Simd | BaryCentric (const S &p1, const T &p2, const U &p3, const V &f, const W &g) noexcept |
Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, typename V , typename W > requires Internal::IsCompatible<S, T> && Internal::IsCompatible<S, U> && IsFloatingPoint<V> && IsFloatingPoint<W> | |
S::Simd | BaryCentric (const S &p1, const T &p2, const U &p3, const V f, const W g) noexcept |
Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::TupleType U, typename V , typename W > requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& IsFloatingPoint<V>&& IsFloatingPoint<W> | |
S::Simd | BaryCentric (const S &p1, const T &p2, const U &p3, const V f, const W g) noexcept |
Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::SimdType W> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& Internal::IsCompatible<S, W> | |
S | CatmullRom (const S &p1, const T &p2, const U &p3, const V &p4, const W &t) noexcept |
Calculates the Catmull-Rom interpolation, using the specified positions. | |
template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::SimdType W> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& Internal::IsCompatible<S, W> | |
S::Simd | CatmullRom (const S &p1, const T &p2, const U &p3, const V &p4, const W &t) noexcept |
Calculates the Catmull-Rom interpolation, using the specified positions. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, typename W > requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& IsFloatingPoint<W> | |
S | CatmullRom (const S &p1, const T &p2, const U &p3, const V &p4, const W t) noexcept |
Calculates the Catmull-Rom interpolation, using the specified positions. | |
template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, typename W > requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& IsFloatingPoint<W> | |
S::Simd | CatmullRom (const S &p1, const T &p2, const U &p3, const V &p4, const W t) noexcept |
Calculates the Catmull-Rom interpolation, using the specified positions. | |
template<Internal::SimdType T, typename ResultT = typename T::value_type> | |
ResultT | MinComponentValue (const T &v) noexcept |
Retrieves the lowest value held by the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::value_type> | |
constexpr ResultT | MinComponentValue (const T &v) noexcept |
Retrieves the lowest value held by the argument. | |
template<Internal::SimdType T, typename ResultT = typename T::value_type> | |
ResultT | MaxComponentValue (const T &v) noexcept |
Retrieves the highest value held by the argument. | |
template<Internal::TupleType T, typename ResultT = typename T::value_type> | |
constexpr ResultT | MaxComponentValue (const T &v) noexcept |
Retrieves the highest value held by the argument. | |
template<Internal::TupleType T> | |
constexpr size_t | MaxComponentIndex (const T &v) noexcept |
Retrieves the offset of the highest value held by the argument. | |
template<Internal::SimdType T, typename ResultT = typename T::value_type> | |
constexpr size_t | MaxComponentIndex (const T &v) noexcept |
Retrieves the offset of the highest value held by the argument. | |
template<Internal::TupleType T> | |
constexpr size_t | MinComponentIndex (const T &v) noexcept |
Retrieves the offset of the lowest value held by the argument. | |
template<Internal::SimdType T, typename ResultT = typename T::value_type> | |
constexpr size_t | MinComponentIndex (const T &v) noexcept |
Retrieves the offset of the lowest value held by the argument. | |
template<VectorSimdType S, VectorSimdType T> requires Internal::IsCompatible<S, T> | |
S | AngleBetween (const S &v1, const T &v2) noexcept |
Calculates the angle in radians between two vectors. | |
template<VectorSimdType S, VectorSimdType T> requires Internal::IsCompatible<S, T> | |
S | AngleBetweenNormals (const S &v1, const T &v2) noexcept |
Calculates the angle in radians between two normalized vectors. | |
Point2f | InvertBilinear (const Point2f &p, const std::span< const Point2f > &vert) |
template<PointSimdType S, PointSimdType T, PointSimdType U> requires Internal::IsCompatible<S,T> && Internal::IsCompatible<S, U> | |
S | LinePointDistance (const S &linePoint1, const T &linePoint2, const U &point) noexcept |
Calculates the minimum distance between a line and a point. | |
template<Internal::QuaternionSimdType T, Internal::QuaternionSimdType U> requires Internal::IsCompatibleQuaternion<T,U> | |
T | operator+ (const T &q1, const U &q2) noexcept |
template<Internal::QuaternionType T, Internal::QuaternionSimdType U> requires Internal::IsCompatibleQuaternion<T, U> | |
U | operator+ (const T &q1, const U &q2) noexcept |
template<Internal::QuaternionSimdType T, Internal::QuaternionType U> requires Internal::IsCompatibleQuaternion<T, U> | |
T | operator+ (const T &q1, const U &q2) noexcept |
template<Internal::QuaternionType T, Internal::QuaternionType U> requires Internal::IsCompatibleQuaternion<T, U> | |
T::Simd | operator+ (const T &q1, const U &q2) noexcept |
template<Internal::QuaternionSimdType T, typename U > requires std::is_arithmetic_v<U> | |
T | operator+ (const T &q1, const U value) noexcept |
template<typename T , Internal::QuaternionSimdType U> requires std::is_arithmetic_v<T> | |
U | operator+ (const T &value, const U &q2) noexcept |
template<Internal::QuaternionType T, typename U > requires std::is_arithmetic_v<U> | |
T::Simd | operator+ (const T &q1, const U value) noexcept |
template<typename T , Internal::QuaternionType U> requires std::is_arithmetic_v<T> | |
U::Simd | operator+ (const T value, const U &q2) noexcept |
template<Internal::QuaternionSimdType T, Internal::QuaternionSimdType U> requires Internal::IsCompatibleQuaternion<T, U> | |
T | operator- (const T &q1, const U &q2) noexcept |
template<Internal::QuaternionType T, Internal::QuaternionSimdType U> requires Internal::IsCompatibleQuaternion<T, U> | |
U | operator- (const T &q1, const U &q2) noexcept |
template<Internal::QuaternionType T, Internal::QuaternionType U> requires Internal::IsCompatibleQuaternion<T, U> | |
T::Simd | operator- (const T &q1, const U &q2) noexcept |
template<Internal::QuaternionSimdType T, typename U > requires std::is_arithmetic_v<U> | |
T | operator- (const T &q1, const U value) noexcept |
template<typename T , Internal::QuaternionSimdType U> requires std::is_arithmetic_v<T> | |
U | operator- (const T value, const U &q2) noexcept |
template<Internal::QuaternionType T, typename U > requires std::is_arithmetic_v<U> | |
T::Simd | operator- (const T &q1, const U value) noexcept |
template<typename T , Internal::QuaternionType U> requires std::is_arithmetic_v<T> | |
U::Simd | operator- (const T value, const U &q2) noexcept |
template<Internal::QuaternionSimdType T, Internal::QuaternionSimdType U> requires Internal::IsCompatibleQuaternion<T, U> | |
T | operator* (const T &q1, const U &q2) noexcept |
template<Internal::QuaternionType T, Internal::QuaternionSimdType U> requires Internal::IsCompatibleQuaternion<T, U> | |
U | operator* (const T &q1, const U &q2) noexcept |
template<Internal::QuaternionType T, Internal::QuaternionType U> requires Internal::IsCompatibleQuaternion<T, U> | |
T::Simd | operator* (const T &q1, const U &q2) noexcept |
template<typename T , Internal::QuaternionSimdType U> requires IsFloatingPoint<T> | |
U | operator* (T value, const U &q2) noexcept |
template<Internal::QuaternionSimdType T, typename U > requires IsFloatingPoint<U> | |
T | operator* (const T &q1, U value) noexcept |
template<typename T , Internal::QuaternionType U> requires IsFloatingPoint<T> | |
U::Simd | operator* (T value, const U &q2) noexcept |
template<Internal::QuaternionType T, typename U > requires IsFloatingPoint<U> | |
T::Simd | operator* (const T &q1, U value) noexcept |
template<Internal::QuaternionSimdType T, typename U > requires IsFloatingPoint<U> | |
T | operator/ (const T &q1, U value) noexcept |
template<typename T , Internal::QuaternionSimdType U> requires IsFloatingPoint<T> | |
U | operator/ (const T value, const U &q2) noexcept |
template<Internal::QuaternionType T, typename U > requires IsFloatingPoint<U> | |
T::Simd | operator/ (const T &q1, U value) noexcept |
template<typename T , Internal::QuaternionType U> requires IsFloatingPoint<T> | |
U::Simd | operator/ (const T value, const U &q2) noexcept |
template<typename T > requires IsFloatingPoint<T> | |
Vector< T, 4 >::Simd | Dot (const QuaternionSimd< Quaternion< T > > &q1, const QuaternionSimd< Quaternion< T > > &q2) noexcept |
Calculates the dot product of two quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
Vector< T, 4 >::Simd | Dot (const Quaternion< T > &q1, const QuaternionSimd< Quaternion< T > > &q2) noexcept |
Calculates the dot product of two quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
Vector< T, 4 >::Simd | Dot (const QuaternionSimd< Quaternion< T > > &q1, const Quaternion< T > &q2) noexcept |
Calculates the dot product of two quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
Vector< T, 4 >::Simd | Dot (const Quaternion< T > &q1, const Quaternion< T > &q2) noexcept |
Calculates the dot product of two quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
Vector< T, 4 >::Simd | Length (const QuaternionSimd< Quaternion< T > > &q1) noexcept |
Calculates the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
Vector< T, 4 >::Simd | Length (const Quaternion< T > &q1) noexcept |
Calculates the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
T | ScalarLength (const QuaternionSimd< Quaternion< T > > &q1) noexcept |
Calculates the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
T | ScalarLength (const Quaternion< T > &q1) noexcept |
Calculates the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
Vector< T, 4 >::Simd | LengthSquared (const QuaternionSimd< Quaternion< T > > &q1) noexcept |
Calculates the square of the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
Vector< T, 4 >::Simd | LengthSquared (const Quaternion< T > &q1) noexcept |
Calculates the square of the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
T | ScalarLengthSquared (const QuaternionSimd< Quaternion< T > > &q1) noexcept |
Calculates the square of the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
T | ScalarLengthSquared (const Quaternion< T > &q1) noexcept |
Calculates the square of the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
Vector< T, 4 >::Simd | ReciprocalLength (const QuaternionSimd< Quaternion< T > > &q1) noexcept |
Calculates the reciprocal of the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
Vector< T, 4 >::Simd | ReciprocalLength (const Quaternion< T > &q1) noexcept |
Calculates the reciprocal of the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
T | ScalarReciprocalLength (const QuaternionSimd< Quaternion< T > > &q1) noexcept |
Calculates the reciprocal of the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
T | ScalarReciprocalLength (const Quaternion< T > &q1) noexcept |
Calculates the reciprocal of the magnitude of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Conjugate (const QuaternionSimd< Quaternion< T > > &q1) noexcept |
Calculates the conjugate of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Conjugate (const Quaternion< T > &q1) noexcept |
Calculates the conjugate of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Normalize (const QuaternionSimd< Quaternion< T > > &q1) noexcept |
Normalizes a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Normalize (const Quaternion< T > &q1) noexcept |
Normalizes a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Inverse (const QuaternionSimd< Quaternion< T > > &q1) noexcept |
Calculates the inverse of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Inverse (const Quaternion< T > &q1) noexcept |
Calculates the inverse of a quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Log (const QuaternionSimd< Quaternion< T > > &q1) noexcept |
Calculates the natural logarithm of a unit quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Log (const Quaternion< T > &q1) noexcept |
Calculates the natural logarithm of a unit quaternion. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const QuaternionSimd< Quaternion< T > > &q1, const QuaternionSimd< Quaternion< T > > &q2, const typename Vector< T, 4 >::Simd &t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const QuaternionSimd< Quaternion< T > > &q1, const QuaternionSimd< Quaternion< T > > &q2, const T t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const QuaternionSimd< Quaternion< T > > &q1, const QuaternionSimd< Quaternion< T > > &q2, const Vector< T, 4 > &t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const QuaternionSimd< Quaternion< T > > &q1, const Quaternion< T > &q2, const typename Vector< T, 4 >::Simd &t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const QuaternionSimd< Quaternion< T > > &q1, const Quaternion< T > &q2, const Vector< T, 4 > &t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const Quaternion< T > &q1, const QuaternionSimd< Quaternion< T > > &q2, const typename Vector< T, 4 >::Simd &t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const Quaternion< T > &q1, const QuaternionSimd< Quaternion< T > > &q2, const Vector< T, 4 > &t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const Quaternion< T > &q1, const Quaternion< T > &q2, const typename Vector< T, 4 >::Simd &t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const Quaternion< T > &q1, const Quaternion< T > &q2, const Vector< T, 4 > &t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const QuaternionSimd< Quaternion< T > > &q1, const Quaternion< T > &q2, const T t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const Quaternion< T > &q1, const QuaternionSimd< Quaternion< T > > &q2, const T t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<typename T > requires IsFloatingPoint<T> | |
QuaternionSimd< Quaternion< T > > | Slerp (const Quaternion< T > &q1, const Quaternion< T > &q2, const T t) noexcept |
Spherical linear interpolation between two unit quaternions. | |
template<Internal::SimdType S, typename FloatT = typename S::value_Type> requires ( S::Size == 3 ) | |
S | Rotate (const S &v, const QuaternionSimd< Quaternion< FloatT > > &rotationQuaternion) |
Rotates a vector using a quaternion. | |
template<Internal::SimdType S, typename FloatT = typename S::value_Type> requires ( S::Size == 3 ) | |
S | Rotate (const S &v, const Quaternion< FloatT > &rotationQuaternion) |
Rotates a vector using a quaternion. | |
template<Internal::TupleType S, typename FloatT = typename S::value_Type> requires ( S::Size == 3 ) | |
S::Simd | Rotate (const S &v, const QuaternionSimd< Quaternion< FloatT > > &rotationQuaternion) |
Rotates a vector using a quaternion. | |
template<Internal::TupleType S, typename FloatT = typename S::value_Type> requires ( S::Size == 3 ) | |
S::Simd | Rotate (const S &v, const Quaternion< FloatT > &rotationQuaternion) |
Rotates a vector using a quaternion. | |
template<Internal::SimdType S, typename FloatT = typename S::value_Type> requires ( S::Size == 3 ) | |
S | InverseRotate (const S &v, const QuaternionSimd< Quaternion< FloatT > > &rotationQuaternion) |
Rotates a vector using the inverse of a quaternion. | |
template<Internal::SimdType S, typename FloatT = typename S::value_Type> requires ( S::Size == 3 ) | |
S | InverseRotate (const S &v, const Quaternion< FloatT > &rotationQuaternion) |
Rotates a vector using the inverse of a quaternion. | |
template<Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<T, U> | |
constexpr auto | ScalarAngleBetween (const T &v1, const U &v2) |
template<typename DerivedT , typename FloatT > | |
constexpr FloatT | ScalarAngleBetween (const Tuple3< DerivedT, FloatT > &v1, const Tuple3< DerivedT, FloatT > &v2) |
template<typename DerivedT , typename FloatT > | |
Tuple3< DerivedT, FloatT > | AngleBetween (const Tuple3< DerivedT, FloatT > &v1, const Tuple3< DerivedT, FloatT > &v2) |
template<Internal::SquareMatrixSimdType T1, Internal::SquareMatrixSimdType T2> requires Internal::IsCompatibleMatrix<T1,T2> | |
T1 | operator+ (const T1 &m1, const T2 &m2) noexcept |
template<Internal::SquareMatrixType T1, Internal::SquareMatrixSimdType T2> requires Internal::IsCompatibleMatrix<T1, T2> | |
T2 | operator+ (const T1 &m1, const T2 &m2) noexcept |
template<Internal::SquareMatrixSimdType T1, Internal::SquareMatrixType T2> requires Internal::IsCompatibleMatrix<T1, T2> | |
T1 | operator+ (const T1 &m1, const T2 &m2) noexcept |
template<Internal::SquareMatrixType T1, Internal::SquareMatrixType T2> requires Internal::IsCompatibleMatrix<T1, T2> | |
auto | operator+ (const T1 &m1, const T2 &m2) noexcept |
template<Internal::SquareMatrixSimdType T1, Internal::SquareMatrixSimdType T2> requires Internal::IsCompatibleMatrix<T1, T2> | |
T1 | operator- (const T1 &m1, const T2 &m2) noexcept |
template<Internal::SquareMatrixType T1, Internal::SquareMatrixSimdType T2> requires Internal::IsCompatibleMatrix<T1, T2> | |
T2 | operator- (const T1 &m1, const T2 &m2) noexcept |
template<Internal::SquareMatrixType T1, Internal::SquareMatrixType T2> requires Internal::IsCompatibleMatrix<T1, T2> | |
auto | operator- (const T1 &m1, const T2 &m2) noexcept |
template<Internal::SquareMatrixSimdType T1, typename T2 > requires std::is_arithmetic_v<T2> | |
T1 | operator* (const T1 &m, const T2 value) noexcept |
template<Internal::SquareMatrixType T1, typename T2 > requires IsFloatingPoint<T2> | |
auto | operator* (const T1 &m, const T2 value) noexcept |
template<Internal::SquareMatrixSimdType T1, typename T2 > requires IsFloatingPoint<T2> | |
auto | operator* (const T2 value, const T1 &m) noexcept |
SquareMatrix< float, 4 >::Simd | Multiply (const typename SquareMatrix< float, 4 >::Simd &matrix1, const typename SquareMatrix< float, 4 >::Simd &matrix2) |
SquareMatrix< float, 3 >::Simd | Multiply (const typename SquareMatrix< float, 3 >::Simd &matrix1, const typename SquareMatrix< float, 3 >::Simd &matrix2) |
SquareMatrix< float, 2 >::Simd | Multiply (const typename SquareMatrix< float, 2 >::Simd &matrix1, const typename SquareMatrix< float, 2 >::Simd &matrix2) |
template<Internal::SquareMatrixSimdType T1, Internal::SquareMatrixSimdType T2> requires Internal::IsCompatibleMatrix<T1, T2> | |
T2 | operator* (const T1 &m1, const T2 &m2) noexcept |
template<Internal::SquareMatrixSimdType T1, Internal::SquareMatrixType T2> requires Internal::IsCompatibleMatrix<T1, T2> | |
T1 | operator* (const T1 &m1, const T2 &m2) noexcept |
template<Internal::SquareMatrixType T1, Internal::SquareMatrixType T2> requires Internal::IsCompatibleMatrix<T1, T2> | |
auto | operator* (const T1 &m1, const T2 &m2) noexcept |
template<Internal::SquareMatrixSimdType T1, typename T2 > requires std::is_arithmetic_v<T2> | |
T1 | operator/ (const T1 &m, const T2 value) noexcept |
Vector< float, 4 >::Simd | Determinant (const typename SquareMatrix< float, 4 >::Simd &matrix) |
Calculates the determinant of a matrix. | |
Vector< float, 4 >::Simd | Determinant (const SquareMatrix< float, 4ULL > &matrix) |
Calculates the determinant of a matrix. | |
float | ScalarDeterminant (const SquareMatrix< float, 4 >::Simd &matrix) |
Calculates the determinant of a matrix. | |
float | ScalarDeterminant (const SquareMatrix< float, 4 > &matrix) |
Calculates the determinant of a matrix. | |
Vector< float, 3 >::Simd | Determinant (const typename SquareMatrix< float, 3 >::Simd &matrix) |
Vector< float, 3 >::Simd | Determinant (const typename SquareMatrix< float, 3 > &matrix) |
float | ScalarDeterminant (const SquareMatrix< float, 3 >::Simd &matrix) |
float | ScalarDeterminant (const SquareMatrix< float, 3 > &matrix) |
SquareMatrix< float, 3 >::Simd | Transpose (const SquareMatrix< float, 3 >::Simd &matrix) |
SquareMatrix< float, 3 >::Simd | Transpose (const SquareMatrix< float, 3 > &matrix) |
SquareMatrix< float, 4 >::Simd | Transpose (const SquareMatrix< float, 4 >::Simd &matrix) |
Calculates the transpose of the matrix. | |
SquareMatrix< float, 4 >::Simd | Transpose (const SquareMatrix< float, 4 > &matrix) |
Calculates the transpose of the matrix. | |
SquareMatrix< float, 4 >::Simd | Inverse (const SquareMatrix< float, 4 >::Simd &matrix, typename Vector< float, 4 >::Simd *determinant=nullptr) |
Calculates the inverse of the matrix. | |
SquareMatrix< float, 4 >::Simd | Inverse (const SquareMatrix< float, 4 > &matrix, typename Vector< float, 4 >::Simd *determinant=nullptr) |
Calculates the inverse of the matrix. | |
SquareMatrix< float, 3 >::Simd | Inverse (const typename SquareMatrix< float, 3 >::Simd &matrix, typename Vector< float, 3 >::Simd *determinant=nullptr) |
SquareMatrix< float, 3 >::Simd | Inverse (const SquareMatrix< float, 3 > &matrix, typename Vector< float, 3 >::Simd *determinant=nullptr) |
SquareMatrix< float, 2 >::Simd | Transpose (const typename SquareMatrix< float, 2 >::Simd &matrix) |
SquareMatrix< float, 2 >::Simd | Transpose (const SquareMatrix< float, 2 > &matrix) |
Vector< float, 2 >::Simd | Determinant (const typename SquareMatrix< float, 2 >::Simd &matrix) |
Vector< float, 2 >::Simd | Determinant (const SquareMatrix< float, 2 > &matrix) |
SquareMatrix< float, 2 >::Simd | Inverse (const typename SquareMatrix< float, 2 >::Simd &matrix, typename SquareMatrix< float, 2 >::Simd *determinant=nullptr) |
SquareMatrix< float, 2 >::Simd | Inverse (const SquareMatrix< float, 2 > &matrix) |
SquareMatrix< float, 4 >::Simd | Translation (float offsetX, float offsetY, float offsetZ) |
Creates a translation matrix using the provided offsets. | |
template<Internal::SimdType S> requires (S::Size > 2) && std::is_same_v<typename S::value_type, float> | |
SquareMatrix< float, 4 >::Simd | Translation (const S &offsets) |
Creates a translation matrix using the provided offsets. | |
template<Internal::TupleType S> requires ( S::Size > 2 ) && std::is_same_v<typename S::value_type, float> | |
SquareMatrix< float, 4 >::Simd | Translation (const S &offsets) |
Creates a translation matrix using the provided offsets. | |
SquareMatrix< float, 3 >::Simd | Translation (float offsetX, float offsetY) |
SquareMatrix< float, 4 >::Simd | Scaling (float scaleX, float scaleY, float scaleZ) |
Creates a transformation matrix for scaling along the x-axis, y-axis, and z-axis. | |
SquareMatrix< float, 4 >::Simd | Scaling (float scale) |
Creates a transformation matrix for scaling along the x-axis, y-axis, and z-axis. | |
template<Internal::SimdType S> requires ( S::Size > 2 ) | |
SquareMatrix< float, 4 >::Simd | Scaling (const S &v) noexcept |
Creates a transformation matrix for scaling along the x-axis, y-axis, and z-axis. | |
SquareMatrix< float, 3 >::Simd | Scaling (float scaleX, float scaleY) |
template<Internal::SimdType S> requires (S::Size > 2) | |
SquareMatrix< float, 4 >::Simd | Rotation (const S &v) noexcept |
Creates a transformation matrix that rotates about the y-axis, then the x-axis, and finally the z-axis. | |
template<Internal::TupleType S> requires ( S::Size > 2 ) | |
SquareMatrix< float, 4 >::Simd | Rotation (const S &v) noexcept |
Creates a transformation matrix that rotates about the y-axis, then the x-axis, and finally the z-axis. | |
SquareMatrix< float, 4 >::Simd | Rotation (float xAxisRotation, float yAxisRotation, float zAxisRotation) noexcept |
Creates a transformation matrix that rotates about the y-axis, then the x-axis, and finally the z-axis. | |
SquareMatrix< float, 4 >::Simd | RotationX (float angle) noexcept |
Creates a matrix that rotates around the x-axis. | |
SquareMatrix< float, 4 >::Simd | RotationY (float angle) noexcept |
Creates a matrix that rotates around the y-axis. | |
SquareMatrix< float, 4 >::Simd | RotationZ (float angle) noexcept |
Creates a matrix that rotates around the z-axis. | |
template<Internal::SimdType S> requires ( S::Size > 2 ) | |
SquareMatrix< float, 4 >::Simd | RotationNormal (const S &normalizedAxis, float angle) noexcept |
Creates a matrix that rotates around a normalized vector. | |
template<Internal::SimdType S> requires ( S::Size > 2 ) | |
SquareMatrix< float, 4 >::Simd | RotationAxis (const S &axis, float angle) noexcept |
Creates a matrix that rotates around an arbitrary axis. | |
SquareMatrix< float, 4 >::Simd | Rotation (const QuaternionSimd< Quaternion< float > > &q) noexcept |
Creates a rotation matrix from a quaternion. | |
SquareMatrix< float, 4 >::Simd | Rotation (const Quaternion< float > &q) noexcept |
Creates a rotation matrix from a quaternion. | |
SquareMatrix< float, 4 >::Simd | RotationQuaternion (const QuaternionSimd< Quaternion< float > > &q) noexcept |
Creates a rotation matrix from a quaternion. | |
SquareMatrix< float, 4 >::Simd | RotationQuaternion (const Quaternion< float > &q) noexcept |
Creates a rotation matrix from a quaternion. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f::Simd &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const QuaternionSimd< Quaternion< float > > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const QuaternionSimd< Quaternion< float > > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept |
Creates a transformation matrix. | |
SquareMatrix< float, 4 >::Simd | TransformationMatrix (const Point3f &scalingOrigin, const Quaternion< float > &scalingOrientationQuaternion, const Vector< float, 3 > &scaling, const Point3f &rotationOrigin, const Quaternion< float > &rotationQuaternion, const Vector< float, 3 > &translation) noexcept |
Creates a transformation matrix. | |
template<Internal::SimdType S, Internal::SimdType T, typename U , Internal::SimdType W> requires (S::Size > 2) && (T::Size > 2) && (W::Size > 2) && IsFloatingPoint<U> && std::is_same_v<typename S::value_type,U> && std::is_same_v<typename T::value_type, U> && std::is_same_v<typename W::value_type, U> | |
SquareMatrix< U, 4 >::Simd | AffineTransformationMatrix (const S &scaling, const T &rotationOrigin, const QuaternionSimd< Quaternion< U > > &rotationQuaternion, const W &translation) noexcept |
Creates an affine transformation matrix. | |
template<Internal::SimdType S, Internal::SimdType T, typename U , Internal::SimdType W> requires (S::Size > 2) && (T::Size > 2) && (W::Size > 2) && IsFloatingPoint<U> && std::is_same_v<typename S::value_type,U> && std::is_same_v<typename T::value_type, U> && std::is_same_v<typename W::value_type, U> | |
SquareMatrix< U, 4 >::Simd | AffineTransformationMatrix (const S &scaling, const T &rotationOrigin, const Quaternion< U > &rotationQuaternion, const W &translation) noexcept |
Creates an affine transformation matrix. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S,T> && Internal::IsCompatible<S, U> && (S::Size == 3) | |
SquareMatrix< typenameS::value_type, 4 >::Simd | LookTo (const S &cameraPosition, const T &cameraDirection, const U &upDirection) noexcept |
Creates a view matrix using the left-handed coordinate system for the provided camera position, camera direction, and up direction. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::TupleType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U> && ( S::Size == 3 ) | |
SquareMatrix< typenameS::value_type, 4 >::Simd | LookTo (const S &cameraPosition, const T &cameraDirection, const U &upDirection) noexcept |
Creates a view matrix using the left-handed coordinate system for the provided camera position, camera direction, and up direction. | |
template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U> requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U> && ( S::Size == 3 ) | |
SquareMatrix< typenameS::value_type, 4 >::Simd | LookAt (const S &cameraPosition, const T &focusPosition, const U &upDirection) noexcept |
Creates a view matrix using the left-handed coordinate system for the provided camera position, focal point, and up direction. | |
template<typename T > requires IsFloatingPoint<T> | |
SquareMatrix< T, 4 >::Simd | PerspectiveProjection (T viewWidth, T viewHeight, T nearZ, T farZ) noexcept |
Creates a left-handed perspective projection matrix. | |
template<typename T > requires IsFloatingPoint<T> | |
SquareMatrix< T, 4 >::Simd | PerspectiveFovProjection (T fovAngleY, T aspectRatio, T nearZ, T farZ) noexcept |
Creates a left-handed perspective projection matrix based on a field of view. | |
Vector< float, 2 >::Simd | Transform (const Vector< float, 2 >::Simd &v, const SquareMatrix< float, 3 >::Simd &matrix) noexcept |
Transforms a 2D vector by a matrix. | |
Vector< float, 3 >::Simd | Transform (const Vector< float, 3 >::Simd &v, const SquareMatrix< float, 4 >::Simd &matrix) noexcept |
Applies a transformation matrix to a 3D vector. | |
Vector< float, 3 >::Simd | Transform (const Vector< float, 3 > &v, const SquareMatrix< float, 4 >::Simd &matrix) noexcept |
Applies a transformation matrix to a 3D vector. | |
Vector< float, 3 >::Simd | Transform (const Vector< float, 3 >::Simd &v, const SquareMatrix< float, 4 > &matrix) noexcept |
Applies a transformation matrix to a 3D vector. | |
Vector< float, 3 >::Simd | Transform (const Vector< float, 3 > &v, const SquareMatrix< float, 4 > &matrix) noexcept |
Applies a transformation matrix to a 3D vector. | |
Vector< float, 4 >::Simd | Transform (const Vector< float, 4 >::Simd &v, const SquareMatrix< float, 4 >::Simd &matrix) noexcept |
Point2f::Simd | Transform (const Point2f::Simd &p, const SquareMatrix< float, 3 >::Simd &matrix) noexcept |
Applies a transformation matrix to a 2D coordinate. | |
Point3f::Simd | Transform (const Point3f::Simd &p, const SquareMatrix< float, 4 >::Simd &matrix) noexcept |
Applies a transformation matrix to a 3D coordinate. | |
Point3f::Simd | Transform (const Point3f &p, const SquareMatrix< float, 4 >::Simd &matrix) noexcept |
Applies a transformation matrix to a 3D coordinate. | |
Point3f::Simd | Transform (const Point3f::Simd &p, const SquareMatrix< float, 4 > &matrix) noexcept |
Applies a transformation matrix to a 3D coordinate. | |
Point3f::Simd | Transform (const Point3f &p, const SquareMatrix< float, 4 > &matrix) noexcept |
Applies a transformation matrix to a 3D coordinate. | |
Normal3f::Simd | Transform (const Normal3f::Simd &n, const SquareMatrix< float, 3 >::Simd &matrix) noexcept |
Applies a transformation matrix to a normal. | |
Normal3f::Simd | Transform (const Normal3f::Simd &n, const SquareMatrix< float, 4 >::Simd &matrix) noexcept |
Applies a transformation matrix to a normal. | |
Normal3f::Simd | Transform (const Normal3f &n, const SquareMatrix< float, 3 >::Simd &matrix) noexcept |
Applies a transformation matrix to a normal. | |
Normal3f::Simd | Transform (const Normal3f &n, const SquareMatrix< float, 4 >::Simd &matrix) noexcept |
Applies a transformation matrix to a normal. | |
Normal3f::Simd | Transform (const Normal3f::Simd &n, const SquareMatrix< float, 3 > &matrix) noexcept |
Applies a transformation matrix to a normal. | |
Normal3f::Simd | Transform (const Normal3f::Simd &n, const SquareMatrix< float, 4 > &matrix) noexcept |
Applies a transformation matrix to a normal. | |
Normal3f::Simd | Transform (const Normal3f &n, const SquareMatrix< float, 3 > &matrix) noexcept |
Applies a transformation matrix to a normal. | |
Normal3f::Simd | Transform (const Normal3f &n, const SquareMatrix< float, 4 > &matrix) noexcept |
Applies a transformation matrix to a normal. | |
template<Internal::SimdType S, typename FloatT = S::value_type, typename MatrixT = typename SquareMatrix<FloatT, 4>::Simd> | |
S | Project (const S &v, FloatT viewportX, FloatT viewportY, FloatT viewportWidth, FloatT viewportHeight, FloatT viewportMinZ, FloatT viewportMaxZ, const MatrixT &projection, const MatrixT &viewTransform, const MatrixT &WorldTransform) noexcept |
Projects a 3D coordinate from object space into screen space. | |
constexpr Harlinn::Windows::Point | Min (const Harlinn::Windows::Point &first, const Harlinn::Windows::Point &second) |
constexpr Harlinn::Windows::Point | Max (const Harlinn::Windows::Point &first, const Harlinn::Windows::Point &second) |
constexpr Harlinn::Windows::Graphics::PointF | Min (const Harlinn::Windows::Graphics::PointF &first, const Harlinn::Windows::Graphics::PointF &second) |
constexpr Harlinn::Windows::Graphics::PointF | Max (const Harlinn::Windows::Graphics::PointF &first, const Harlinn::Windows::Graphics::PointF &second) |
constexpr Harlinn::Windows::Size | Min (const Harlinn::Windows::Size &first, const Harlinn::Windows::Size &second) |
constexpr Harlinn::Windows::Size | Max (const Harlinn::Windows::Size &first, const Harlinn::Windows::Size &second) |
constexpr Harlinn::Windows::Graphics::SizeF | Min (const Harlinn::Windows::Graphics::SizeF &first, const Harlinn::Windows::Graphics::SizeF &second) |
constexpr Harlinn::Windows::Graphics::SizeF | Max (const Harlinn::Windows::Graphics::SizeF &first, const Harlinn::Windows::Graphics::SizeF &second) |
template<typename T > requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::PointT> | |
constexpr std::remove_cvref_t< T > | Clamp (T value, T minimumValue, T maximumValue) noexcept |
template<typename T > requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::SizeT> | |
constexpr std::remove_cvref_t< T > | Clamp (T value, T minimumValue, T maximumValue) noexcept |
template<typename T > requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::PointT> | |
constexpr std::remove_cvref_t< T > | Floor (T value) noexcept |
template<typename T > requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::SizeT> | |
constexpr std::remove_cvref_t< T > | Floor (T value) noexcept |
template<typename T > requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::PointT> | |
constexpr std::remove_cvref_t< T > | Ceil (T value) noexcept |
template<typename T > requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::SizeT> | |
constexpr std::remove_cvref_t< T > | Ceil (T value) noexcept |
template<typename T > requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::PointT> | |
constexpr std::remove_cvref_t< T > | Lerp (T a, T b, T t) noexcept |
template<typename T , typename U > requires (Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::PointT> && IsFloatingPoint<U> ) | |
constexpr std::remove_cvref_t< T > | Lerp (T a, T b, U t) noexcept |
template<typename T > requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::SizeT> | |
constexpr std::remove_cvref_t< T > | Lerp (T a, T b, T t) noexcept |
Variables | |
template<typename T > | |
constexpr bool | IsLoadedType = T::Loaded |
template<typename T > | |
constexpr bool | IsUnloadedType = T::Unloaded |
using Harlinn::Common::Core::Math::Vector2f = Vector<float,2> |
using Harlinn::Common::Core::Math::Vector2i = Vector<int,2> |
using Harlinn::Common::Core::Math::Vector3f = Vector<float,3> |
using Harlinn::Common::Core::Math::Vector3i = Vector<int, 3> |
|
strong |
|
inline |
Computes the absolute value of each element held by the argument.
|
inlinenoexcept |
Computes the absolute value of each element held by the argument.
Computes the absolute value of a signed integer number. The behavior is undefined if the result cannot be represented by the return type.
In 2's complement systems, the absolute value of the most-negative value is out of range, e.g. for 32-bit 2's complement type int, INT_MIN is -2147483648, but the would-be result 2147483648 is greater than INT_MAX, which is 2147483647.
T | Any signed integer type. |
val | A signed integer value. |
The absolute value of any unsigned integer is the same as its value.
T | Any unsigned integer type. |
val | An unsigned integer value. |
Computes the absolute value of a floating point value.
T | A floating point type. |
val | A floating point value. |
|
inline |
Calculates the absolute value of the dot product between v1 and v2.
|
inlinenoexcept |
Calculates the absolute value of the dot product between v1 and v2.
Calculates the absolute value of the dot product between v1 and v2.
|
inline |
Calculates the inverse cosine of each element in the argument, in radians.
|
inlinenoexcept |
Calculates the inverse cosine of each element in the argument, in radians.
Computes the principal value of the arc cosine of x.
T | A floating point type. |
x | A floating point value. |
Calculates the inverse hyperbolic cosine of each element in the argument, in radians.
|
inlinenoexcept |
Calculates the inverse hyperbolic cosine of each element in the argument, in radians.
Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI)
|
inlinenoexcept |
Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI)
Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI)
|
inlineconstexpr |
|
inlineconstexpr |
|
inlinenoexcept |
Creates an affine transformation matrix.
scaling | The scaling factors for each dimension. |
rotationOrigin | The center of rotation. |
rotationQuaternion | Rotation factors as a quaternion. |
translation | The translation offsets. |
|
inlinenoexcept |
Creates an affine transformation matrix.
scaling | The scaling factors for each dimension. |
rotationOrigin | The center of rotation. |
rotationQuaternion | Rotation factors as a quaternion. |
translation | The translation offsets. |
|
inlinenoexcept |
Calculates the angle in radians between two vectors.
v1 | The first vector. |
v2 | The second vector. |
|
inline |
|
inlinenoexcept |
Calculates the angle in radians between two normalized vectors.
v1 | The first normalized vector. |
v2 |
The second normalized vector.
Calculates the inverse sine of each element in the argument, in radians.
|
inlinenoexcept |
Calculates the inverse sine of each element in the argument, in radians.
Computes the principal value of the arc sine of x.
T | A floating point type. |
x | A floating point value. |
Calculates the inverse hyperbolic sine of each element in the argument, in radians.
|
inlinenoexcept |
Calculates the inverse hyperbolic sine of each element in the argument, in radians.
Calculates the inverse tangent of each element in the argument, in radians.
|
inlinenoexcept |
Calculates the inverse tangent of each element in the argument, in radians.
Computes the principal value of the arc tangent of x.
T | A floating point type. |
x | A floating point value. |
Computes the arc tangent of x / y using the signs of arguments to determine the correct quadrant.
T | A floating point type. |
x | A floating point value. |
y | A floating point value. |
Calculates the inverse tangent of each element in x divided by the corresponding element in y, in radians.
|
inlinenoexcept |
Calculates the inverse tangent of each element in x divided by the corresponding element in y, in radians.
Calculates the inverse tangent of each element in x divided by the corresponding element in y, in radians.
Computes the arc tangent of x / y using the signs of arguments to determine the correct quadrant.
T | A floating point type. |
x | A floating point value. |
y | A floating point value. |
Calculates the inverse hyperbolic tangent of each element in the argument, in radians.
|
inlinenoexcept |
Calculates the inverse hyperbolic tangent of each element in the argument, in radians.
|
inlinenoexcept |
Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.
p1 | The first position. |
p2 | The second position. |
p3 | The third position. |
f | Weighting factor. |
g | Weighting factor. |
|
inlinenoexcept |
Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.
p1 | The first position. |
p2 | The second position. |
p3 | The third position. |
f | Weighting factor. |
g | Weighting factor. |
|
inlinenoexcept |
Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.
p1 | The first position. |
p2 | The second position. |
p3 | The third position. |
f | Weighting factor. |
g | Weighting factor. |
|
inlinenoexcept |
Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.
p1 | The first position. |
p2 | The second position. |
p3 | The third position. |
f | Weighting factor. |
g | Weighting factor. |
|
inlinenoexcept |
Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.
p1 | The first position. |
p2 | The second position. |
p3 | The third position. |
f | Weighting factor. |
g | Weighting factor. |
|
inlinenoexcept |
Calculates the Catmull-Rom interpolation, using the specified positions.
p1 | The first position. |
p2 | The second position. |
p3 | The third position. |
p4 | The fourth position. |
t | The interpolation control factors. |
|
inlinenoexcept |
Calculates the Catmull-Rom interpolation, using the specified positions.
p1 | The first position. |
p2 | The second position. |
p3 | The third position. |
p4 | The fourth position. |
t | The interpolation control factors. |
|
inlinenoexcept |
Calculates the Catmull-Rom interpolation, using the specified positions.
p1 | The first position. |
p2 | The second position. |
p3 | The third position. |
p4 | The fourth position. |
t | The interpolation control factors. |
|
inlinenoexcept |
Calculates the Catmull-Rom interpolation, using the specified positions.
p1 | The first position. |
p2 | The second position. |
p3 | The third position. |
p4 | The fourth position. |
t | The interpolation control factors. |
|
inline |
Computes the ceiling of each element held by the argument.
|
inlinenoexcept |
Computes the ceiling of each element held by the argument.
Computes the smallest integer value not less than value.
T | A floating point type. |
value | A floating point value. |
Just returns value.
T | An integer type. |
value | An integer value. |
|
inlineconstexprnoexcept |
|
inlineconstexprnoexcept |
|
inline |
|
inlinenoexcept |
Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.
|
inlinenoexcept |
Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.
|
inlinenoexcept |
Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.
|
inlinenoexcept |
Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlinenoexcept |
Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.
|
inlineconstexprnoexcept |
|
inlineconstexprnoexcept |
|
inlinenoexcept |
Clamps the length of a vector to a given range.
v | vector to clamp. |
lengthMin | A vector whose elements are equal to the minimum clamp length. The elements must be greater-than-or-equal to zero. |
lengthMax | A vector whose elements are equal to the maximum clamp length. The elements must be greater-than-or-equal to zero. |
|
inlinenoexcept |
Clamps the length of a vector to a given range.
v | vector to clamp. |
lengthMin | A vector whose elements are equal to the minimum clamp length. The elements must be greater-than-or-equal to zero. |
lengthMax | A vector whose elements are equal to the maximum clamp length. The elements must be greater-than-or-equal to zero. |
|
inlinenoexcept |
Clamps the length of a vector to a given range.
v | vector to clamp. |
lengthMin | A vector whose elements are equal to the minimum clamp length. The elements must be greater-than-or-equal to zero. |
lengthMax | A vector whose elements are equal to the maximum clamp length. The elements must be greater-than-or-equal to zero. |
|
inlinenoexcept |
Clamps the length of a vector to a given range.
v | vector to clamp. |
lengthMin | A vector whose elements are equal to the minimum clamp length. The elements must be greater-than-or-equal to zero. |
lengthMax | A vector whose elements are equal to the maximum clamp length. The elements must be greater-than-or-equal to zero. |
|
inlinenoexcept |
Clamps the length of a vector to a given range.
v | vector to clamp. |
lengthMin | A vector whose elements are equal to the minimum clamp length. The elements must be greater-than-or-equal to zero. |
lengthMax | A vector whose elements are equal to the maximum clamp length. The elements must be greater-than-or-equal to zero. |
|
noexcept |
Calculates the conjugate of a quaternion.
q1 | The quaternion. |
|
noexcept |
Calculates the conjugate of a quaternion.
q1 | The quaternion. |
|
inlineconstexprnoexcept |
Composes a floating point value with the magnitude of magnitude
and the sign of signValue
.
T | A floating point type. |
magnitude | A floating point value. |
signValue | A floating point value. |
magnitude
and the sign of signValue
.
|
inline |
Calculates the cosine of each element in the argument expressed in radians.
|
inlinenoexcept |
Calculates the cosine of each element in the argument expressed in radians.
Computes the cosine of x given in radians.
T | A floating point type. |
x | A floating point value. |
Calculates the hyperbolic cosine of each element in the argument expressed in radians.
|
inlinenoexcept |
Calculates the hyperbolic cosine of each element in the argument expressed in radians.
Calculates the cross product between v1 and v2.
|
inlinenoexcept |
Calculates the cross product between v1 and v2.
Calculates the cross product between v1 and v2.
|
inlineconstexprnoexcept |
Converts an angle in degrees into the corresponding angle in radians.
T | A floating point type. |
angleInDegrees | The angle in degrees. |
|
inlineconstexpr |
|
inline |
|
inline |
Calculates the determinant of a matrix.
matrix | The matrix that the determinant will be calculated for. |
|
inline |
|
inline |
|
inline |
|
inline |
Calculates the determinant of a matrix.
matrix | The matrix that the determinant will be calculated for. |
|
inline |
|
inlinenoexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.
|
inlinenoexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.
|
inlinenoexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.
|
inlinenoexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.
|
inlinenoexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.
|
inlinenoexcept |
Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.
|
inlineconstexpr |
Calculates the distance between p1 and p2.
|
inlinenoexcept |
Calculates the distance between p1 and p2.
Calculates the distance between p1 and p2.
Calculates the squared distance between p1 and p2.
|
inlinenoexcept |
Calculates the squared distance between p1 and p2.
Calculates the squared distance between p1 and p2.
|
inlineconstexpr |
|
inlineconstexpr |
|
noexcept |
Calculates the dot product of two quaternions.
q1 | The first quaternion. |
q2 | The second quaternion. |
|
noexcept |
Calculates the dot product of two quaternions.
q1 | The first quaternion. |
q2 | The second quaternion. |
|
noexcept |
Calculates the dot product of two quaternions.
q1 | The first quaternion. |
q2 | The second quaternion. |
|
noexcept |
Calculates the dot product of two quaternions.
q1 | The first quaternion. |
q2 | The second quaternion. |
Calculates the dot product between v1 and v2.
|
inlinenoexcept |
Calculates the dot product between v1 and v2.
Calculates the dot product between v1 and v2.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument.
|
inlinenoexcept |
Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument.
Computes e
, 2.7182818
, raised to the given power x
.
T | A floating point type. |
x | A floating point value. |
e
raised to the given power x
. Calculates the base-10 exponential of each element in the argument.
|
inlinenoexcept |
Calculates the base-10 exponential of each element in the argument.
Calculates the base-2 exponential of each element in the argument.
|
inlinenoexcept |
Calculates the base-2 exponential of each element in the argument.
Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument, $$-1.0$$.
|
inlinenoexcept |
Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument, $$-1.0$$.
|
constexpr |
|
inlineconstexpr |
|
inlineconstexpr |