|
| template<FloatingPointType T> |
| constexpr bool | IsSameValue (T first, T second) noexcept |
| | Tests whether two floating point values holds the same value. This function returns true if both hold the same NaN value.
|
| |
| template<FloatingPointType T> |
| constexpr bool | IsZero (T x) noexcept |
| | Tests if a floating point value is zero.
|
| |
| template<UnsignedIntegerOrBooleanType T> |
| constexpr T | signum (T val) noexcept |
| | Returns the sign of a value for a signed integer type.
|
| |
| template<FloatingPointType T> |
| constexpr T | Deg2Rad (T angleInDegrees) noexcept |
| | Converts an angle in degrees into the corresponding angle in radians.
|
| |
| template<FloatingPointType T> |
| constexpr 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<FloatingPointType T> |
| constexpr T | Sqrt (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | ReciprocalSqrt (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Cbrt (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | NextDown (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | NextUp (T x) noexcept |
| |
| template<IntegerType T> |
| constexpr bool | IsNaN (T val) noexcept |
| | IsNaN for integer types, always returns false.
|
| |
| template<ArithmeticType T, ArithmeticType ... Args> |
| constexpr bool | IsNaN (T val, Args ... args) noexcept |
| | Determines if any of the given integral or floating point values are a not-a-number (NaN) value.
|
| |
| template<IntegerType T> |
| constexpr bool | IsInf (T val) noexcept |
| | Integers cannot represent infinite, so this function always returns false.
|
| |
| template<ArithmeticType T, ArithmeticType ... Args> |
| constexpr bool | IsInf (T val, Args ... args) noexcept |
| | Determines if any of the given integral or floating point numbers is positive or negative infinity.
|
| |
| template<IntegerType T> |
| constexpr bool | IsFinite (T val) noexcept |
| | All integers have finite values.
|
| |
| template<ArithmeticType T, ArithmeticType ... Args> |
| constexpr bool | IsFinite (T val, Args ... args) noexcept |
| | Determines if all the arguments are finite.
|
| |
| template<IntegerType T> |
| constexpr bool | IsNormal (T val) noexcept |
| | All integers, except 0, are <q>normal</q>.
|
| |
| template<ArithmeticType T, ArithmeticType ... Args> |
| constexpr bool | IsNormal (T val, Args ... args) noexcept |
| | Determines if all the arguments are normal.
|
| |
| template<SignedIntegerType T> |
| constexpr T | Abs (T val) noexcept |
| | The absolute value of any unsigned integer is the same as its value.
|
| |
| template<UnsignedIntegerType T> |
| constexpr T | FastAbs (T val) noexcept |
| |
| template<SignedIntegerType T> |
| constexpr bool | SignBit (T val) noexcept |
| | Determines if the given signed integer value is negative.
|
| |
| template<FloatingPointType T> |
| constexpr std::pair< T, int > | FRExp (T val) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | FRExp (T val, int *exp) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | FRExp (T val, int &exp) noexcept |
| |
| template<FloatingPointType T> |
| constexpr std::pair< T, T > | ModF (T val) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | ModF (T val, T *integerPart) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | ModF (T val, T &integerPart) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Min (T first, T second) noexcept |
| | Returns the smaller of the given values.
|
| |
| template<FloatingPointType T, FloatingPointType ... Args> |
| constexpr T | Min (T first, T second, Args... remaining) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Max (T first, T second) noexcept |
| | Returns the larger of the given values.
|
| |
| template<FloatingPointType T, FloatingPointType ... Args> |
| constexpr T | Max (T first, T second, Args... remaining) noexcept |
| |
template<SimpleSpanLike T>
requires IsArithmetic<typename T::value_type> |
| constexpr T::value_type | Multiply (const T &values) |
| |
| template<FloatingPointType T> |
| constexpr T | Trunc (T value) noexcept |
| | Just returns value.
|
| |
| template<FloatingPointType T> |
| constexpr T | Floor (T value) noexcept |
| | Just returns value.
|
| |
| template<FloatingPointType T> |
| constexpr T | Ceil (T value) noexcept |
| | Just returns value.
|
| |
| template<FloatingPointType T> |
| constexpr T | Round (T value) noexcept |
| | Just returns value.
|
| |
| template<ArithmeticType T1, ArithmeticType T2, ArithmeticType T3> |
| constexpr T1 | Clamp (T1 value, T2 minimumValue, T3 maximumValue) noexcept |
| |
| template<ArithmeticType T, ArithmeticType U> |
| constexpr auto | Lerp (T a, T b, U t) noexcept |
| |
| template<ArithmeticType T, ArithmeticType U> |
| constexpr auto | Lerp2 (U t, T a, T b) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | CopySign (T magnitude, T signValue) noexcept |
| |
| constexpr double | ScaleBN (double x, int n) noexcept |
| |
| constexpr float | ScaleBN (float x, int n) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | FMod (T x, T y) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Exp (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | ExpM1 (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Exp2 (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Exp10 (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Hypot (T x, T y) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Hypot (T x, T y, T z) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Log (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Log1P (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Log2 (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Log10 (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | LogB (T x) noexcept |
| | Extracts the value of the unbiased radix-independent exponent from the floating-point argument x, and returns it as a floating-point value.
|
| |
| template<FloatingPointType T> |
| constexpr int | ILogB (T x) noexcept |
| | Extracts the value of the unbiased exponent from the floating-point argument x, and returns it as a signed integer value.
|
| |
| template<FloatingPointType T> |
| constexpr T | Pow (T x, T y) noexcept |
| | Computes the value of x raised to the power y.
|
| |
| template<FloatingPointType T> |
| constexpr T | Sin (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | ASin (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Cos (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | ACos (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | Tan (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | ATan (T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | ATan (T y, T x) noexcept |
| |
| template<FloatingPointType T> |
| constexpr T | ATan2 (T y, T x) noexcept |
| |
| template<FloatingPointType 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<FloatingPointType 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<FloatingPointType T> |
| constexpr T | SinH (T x) noexcept |
| | Calculates the hyperbolic sine of x.
|
| |
| template<FloatingPointType T> |
| constexpr T | ASinH (T x) noexcept |
| | Calculates the inverse hyperbolic sine of x.
|
| |
| template<FloatingPointType T> |
| constexpr T | CosH (T x) noexcept |
| | Calculates the hyperbolic cosine of x.
|
| |
| template<FloatingPointType T> |
| constexpr T | ACosH (T x) noexcept |
| | Calculates the inverse hyperbolic cosine of x.
|
| |
| template<FloatingPointType T> |
| constexpr T | TanH (T x) noexcept |
| | Calculates the hyperbolic tangent of x.
|
| |
| template<FloatingPointType T> |
| constexpr T | ATanH (T x) noexcept |
| | Calculates the inverse hyperbolic tangent of x.
|
| |
| template<FloatingPointType T> |
| constexpr T | J0 (T x) noexcept |
| | Calculates the Bessel function of the first kind of order 0 for x.
|
| |
| template<FloatingPointType T> |
| constexpr T | J1 (T x) noexcept |
| | Calculates the Bessel function of the first kind of order 1 for x.
|
| |
| template<FloatingPointType T> |
| constexpr T | JN (int n, T x) noexcept |
| | Calculates the Bessel function of the first kind of order n for x.
|
| |
| template<FloatingPointType T> |
| constexpr T | Y0 (T x) noexcept |
| | Calculates the Bessel function of the second kind of order 0 for x.
|
| |
| template<FloatingPointType T> |
| constexpr T | Y1 (T x) noexcept |
| | Calculates the Bessel function of the second kind of order 1 for x.
|
| |
| template<FloatingPointType T> |
| constexpr T | YN (int n, T x) noexcept |
| | Calculates the Bessel function of the second kind of order n for x.
|
| |
| template<FloatingPointType T> |
| constexpr T | Erf (T x) noexcept |
| | Computes the error function of x.
|
| |
| template<FloatingPointType T> |
| constexpr T | ErfC (T x) noexcept |
| | Computes the complementary error function of x,.
|
| |
| template<FloatingPointType T> |
| constexpr T | TGamma (T x) noexcept |
| | Computes the gamma function of x.
|
| |
| template<FloatingPointType T> |
| constexpr T | LGamma (T x) noexcept |
| | Computes the natural logarithm of the absolute value of the gamma function of x.
|
| |
| template<FloatingPointType T> |
| constexpr T | Remainder (T x, T y) noexcept |
| | Computes the IEEE remainder of the floating point division operation x / y.
|
| |
| template<FloatingPointType T> |
| constexpr T | RemQuo (T x, T y, int *quo) noexcept |
| | Computes the floating-point remainder of the division operation x / y like Remainder. Additionally, the sign and at least the three of the last bits of x / y will be stored in quo, sufficient to determine the octant of the result within a period.
|
| |
| template<FloatingPointType T> |
| constexpr T | FDim (T x, T y) noexcept |
| | Returns the positive difference between x and y, that is, if x > y, returns x - y, otherwise (i.e. if x <= y) returns +0.
|
| |
| template<IntegerType T> |
| constexpr T | FMA (T a, T b, T c) noexcept |
| | Computes x * y + z.
|
| |
| template<FloatingPointType T> |
| constexpr T | SinXOverX (T x) |
| |
| template<FloatingPointType T> |
| constexpr T | Sinc (T x) |
| |
| template<FloatingPointType T> |
| constexpr T | WindowedSinc (T x, T radius, T tau) |
| |
| template<FloatingPointType T> |
| constexpr T | Mod (T a, T b) |
| |
| template<FloatingPointType T> |
| constexpr T | Radians (T deg) |
| |
| template<FloatingPointType T> |
| constexpr T | Degrees (T rad) |
| |
| template<FloatingPointType T> |
| constexpr T | SmoothStep (T x, T a, T b) |
| |
| template<FloatingPointType T> |
| constexpr T | SafeSqrt (T x) |
| |
template<typename T >
requires IsArithmetic<T> || Internal::IsComplex<T> |
| constexpr T | Sqr (T v) |
| |
| template<int n, FloatingPointType T> |
| constexpr T | FastPow (T v) |
| |
| template<ArithmeticType T, ArithmeticType C> |
| constexpr T | EvaluatePolynomial (T t, C c) |
| |
| template<ArithmeticType T, ArithmeticType C, ArithmeticType ... Args> |
| constexpr T | EvaluatePolynomial (T t, C c, Args... remaining) |
| |
| template<FloatingPointType T> |
| constexpr T | SafeASin (T x) |
| |
| template<FloatingPointType T> |
| constexpr T | SafeACos (T x) |
| |
| template<FloatingPointType T> |
| constexpr T | NextFloatUp (T v) |
| |
| template<FloatingPointType T> |
| constexpr T | NextFloatDown (T v) |
| |
| template<FloatingPointType T> |
| constexpr T | Gamma (int n) |
| |
| template<FloatingPointType T> |
| constexpr T | AddAdjustUp (T a, T b) |
| |
| template<FloatingPointType T> |
| constexpr T | AddAdjustDown (T a, T b) |
| |
| template<FloatingPointType T> |
| constexpr T | SubAdjustUp (T a, T b) |
| |
| template<FloatingPointType T> |
| constexpr T | SubAdjustDown (T a, T b) |
| |
| template<FloatingPointType T> |
| constexpr T | MulAdjustUp (T a, T b) |
| |
| template<FloatingPointType T> |
| constexpr T | MulAdjustDown (T a, T b) |
| |
| template<FloatingPointType T> |
| constexpr T | DivAdjustUp (T a, T b) |
| |
| template<FloatingPointType T> |
| constexpr T | DivAdjustDown (T a, T b) |
| |
| template<FloatingPointType T> |
| constexpr T | SqrtAdjustUp (T a) |
| |
| template<FloatingPointType T> |
| constexpr T | SqrtAdjustDown (T a) |
| |
| template<FloatingPointType T> |
| constexpr T | FMAAdjustUp (T a, T b, T c) |
| |
| template<FloatingPointType T> |
| constexpr T | FMAAdjustDown (T a, T b, T c) |
| |
| template<FloatingPointType T> |
| constexpr T | FastLog2 (T 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> |
| void | SinCos (const Interval< FloatT > &i, Interval< FloatT > *sine, Interval< FloatT > *cosine) |
| |
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<FloatingPointType T, size_t N> |
| Vector< T, N > | Length (const SegmentSimd< T, N > &segment) noexcept |
| |
template<SimdType T, SimdType U>
requires IsCompatible<T, U> |
| auto | operator+ (const T &lhs, const U &rhs) noexcept |
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U>&& Internal::HasTupleType<T, U> |
| auto | operator+ (const T &lhs, const U &rhs) noexcept |
| |
| template<ArithmeticType T, SimdType U> |
| auto | operator+ (const T lhs, const U &rhs) noexcept |
| |
| template<SimdType T, ArithmeticType U> |
| auto | operator+ (const T &lhs, const U rhs) noexcept |
| |
template<SimdType T, SimdType U>
requires IsCompatible<T, U> |
| auto | operator- (const T &lhs, const U &rhs) noexcept |
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U>&& Internal::HasTupleType<T, U> |
| auto | operator- (const T &lhs, const U &rhs) noexcept |
| |
| template<ArithmeticType T, SimdType U> |
| auto | operator- (const T lhs, const U &rhs) noexcept |
| |
| template<SimdType T, ArithmeticType U> |
| auto | operator- (const T &lhs, const U rhs) noexcept |
| |
template<SimdType T, SimdType U>
requires IsCompatible<T, U> |
| auto | operator* (const T &lhs, const U &rhs) noexcept |
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U>&& Internal::HasTupleType<T, U> |
| auto | operator* (const T &lhs, const U &rhs) noexcept |
| |
| template<ArithmeticType T, SimdType U> |
| auto | operator* (const T lhs, const U &rhs) noexcept |
| |
| template<SimdType T, ArithmeticType U> |
| auto | operator* (const T &lhs, const U rhs) noexcept |
| |
template<SimdType T, SimdType U>
requires IsCompatible<T, U> |
| auto | operator/ (const T &lhs, const U &rhs) noexcept |
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U>&& Internal::HasTupleType<T, U> |
| auto | operator/ (const T &lhs, const U &rhs) noexcept |
| |
| template<ArithmeticType T, SimdType U> |
| auto | operator/ (const T lhs, const U &rhs) noexcept |
| |
| template<SimdType T, ArithmeticType U> |
| auto | operator/ (const T &lhs, const U rhs) noexcept |
| |
| template<SimdType T> |
| auto | First (const T &v) |
| | Retrieves the lowest element of v.
|
| |
| template<SimdType T> |
| T | HSum (const T &t) noexcept |
| | Calculates the horizontal sum of the elements in the vector.
|
| |
| template<SimdType T> |
| T::value_type | ScalarHSum (const T &t) noexcept |
| | Calculates the horizontal sum of the elements in the vector.
|
| |
| template<TupleType T> |
| T::Simd | HSum (const T &t) noexcept |
| | Calculates the horizontal sum of the elements in the vector.
|
| |
| template<SimdType T> |
| auto | Avg (const T &t) noexcept |
| |
| template<SimdOrTupleType T> |
| T::value_type | ScalarAvg (const T &t) noexcept |
| | Calculates the average value of the elements in the argument.
|
| |
| template<SimdType T> |
| T | HProd (const T &t) noexcept |
| | Calculates the horizontal product of the elements in the vector.
|
| |
| template<SimdType T> |
| auto | ScalarHProd (const T &t) noexcept |
| |
| template<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<TupleType T> |
| T::Simd | HProd (const T &t) noexcept |
| | Calculates the horizontal product of the elements in the vector.
|
| |
| template<SimdOrTupleType T> |
| bool | AllTrue (const T &v) noexcept |
| | Returns true if all the elements of the argument have all their bits set to 1.
|
| |
| template<SimdOrTupleType T> |
| bool | AnyTrue (const T &v) noexcept |
| | Returns true if any of the elements of the argument have all their bits set to 1.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | Less (const T &v1, const U &v2) noexcept |
| | Determines whether the elements of v1 are less than the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| auto | Less (const T &v1, U value) noexcept |
| | Determines whether the elements of v1 are less than value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| auto | Less (T value, const U &v2) noexcept |
| | Determines whether value is less than the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AllLess (const T &v1, const U &v2) noexcept |
| | Determines whether all the elements of v1 are less than the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AllLess (const T &v1, U value) noexcept |
| | Determines whether all the elements of v1 are less than value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AllLess (T value, const U &v2) noexcept |
| | Determines whether value is less than all of the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AnyLess (const T &v1, const U &v2) noexcept |
| | Determines whether any of the elements of v1 are less than the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AnyLess (const T &v1, U value) noexcept |
| | Determines whether any of the elements of v1 are less than value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AnyLess (T value, const U &v2) noexcept |
| | Determines whether value is less than any of the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | LessOrEqual (const T &v1, const U &v2) noexcept |
| | Determines whether the elements of v1 are less than, or equal to, the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| auto | LessOrEqual (const T &v1, const U value) noexcept |
| | Determines whether the elements of v1 are less than, or equal to, value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| auto | LessOrEqual (const T value, const U &v2) noexcept |
| | Determines whether value is less than, or equal to, the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AllLessOrEqual (const T &v1, const U &v2) noexcept |
| | Determines whether all the elements of v1 are less than, or equal to, the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AllLessOrEqual (const T &v1, const U value) noexcept |
| | Determines whether all the elements of v1 are less than, or equal to, value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AllLessOrEqual (const T value, const U &v2) noexcept |
| | Determines whether value is less than, or equal to, all of the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AnyLessOrEqual (const T &v1, const U &v2) noexcept |
| | Determines whether any of the elements of v1 are less than, or equal to, the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AnyLessOrEqual (const T &v1, const U value) noexcept |
| | Determines whether any of the elements of v1 are less than, or equal to, value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AnyLessOrEqual (const T value, const U &v2) noexcept |
| | Determines whether value is less than, or equal to, any of the elements of v2.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| auto | Equal (const S &lhs, const T &rhs, const U &epsilon) noexcept |
| | Determines whether the elements of lhs and the corresponding elements of rhs are less or equally apart than the corresponding element of epsilon.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, ArithmeticType U>
requires IsCompatible<S, T> |
| auto | Equal (const S &lhs, const T &rhs, U epsilon) noexcept |
| | Determines whether the elements of lhs and the corresponding elements of rhs are less or equally apart than the value of epsilon.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| bool | AllEqual (const S &lhs, const T &rhs, const U &epsilon) noexcept |
| | Determines whether all the elements of lhs and their corresponding element of rhs are less or equally apart than the corresponding element of epsilon.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, ArithmeticType U>
requires IsCompatible<S, T> |
| bool | AllEqual (const S &lhs, const T &rhs, const U epsilon) noexcept |
| | Determines whether all the elements of lhs and their corresponding element of rhs are less or equally apart than the value of epsilon.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| bool | AnyEqual (const S &lhs, const T &rhs, const U &epsilon) noexcept |
| | Determines whether any of the elements of lhs and their corresponding element of rhs are less or equally apart than the corresponding element of epsilon.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, ArithmeticType U>
requires IsCompatible<S, T> |
| bool | AnyEqual (const S &lhs, const T &rhs, U epsilon) noexcept |
| | Determines whether any of the elements of lhs and their corresponding element of rhs are less or equally apart than the value of epsilon.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | Equal (const T &v1, const U &v2) noexcept |
| | Determines whether the elements of v1 are equal to the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| auto | Equal (const T &v1, U value) noexcept |
| | Determines whether the elements of v1 are equal to value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| auto | Equal (const T value, const U &v2) noexcept |
| | Determines whether value is equal to the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AllEqual (const T &v1, const U &v2) noexcept |
| | Determines whether all the elements of v1 are equal to the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AllEqual (const T &v1, const U value) noexcept |
| | Determines whether all the elements of v1 are equal to value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AllEqual (T value, const U &v2) noexcept |
| | Determines whether value is equal to all the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AnyEqual (const T &v1, const U &v2) noexcept |
| | Determines whether any of the elements of v1 are equal to the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AnyEqual (const T &v1, const U value) noexcept |
| | Determines whether any of the elements of v1 are equal to value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AnyEqual (const T value, const U &v2) noexcept |
| | Determines whether value is equal to any of the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | NotEqual (const T &v1, const U &v2) noexcept |
| | Determines whether the elements of v1 are not equal to the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| auto | NotEqual (const T &v1, const U value) noexcept |
| | Determines whether the elements of v1 are not equal to value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| auto | NotEqual (T value, const U &v2) noexcept |
| | Determines whether value is not equal to the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AllNotEqual (const T &v1, const U &v2) noexcept |
| | Determines whether all the elements of v1 are not equal to the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AllNotEqual (const T &v1, const U value) noexcept |
| | Determines whether all the elements of v1 are not equal to value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AllNotEqual (T value, const U &v2) noexcept |
| | Determines whether value is not equal to all the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AnyNotEqual (const T &v1, const U &v2) noexcept |
| | Determines whether any of the elements of v1 are not equal to the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AnyNotEqual (const T &v1, const U value) noexcept |
| | Determines whether any of the elements of v1 are not equal to value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AnyNotEqual (const T value, const U &v2) noexcept |
| | Determines whether value is not equal to any of the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | GreaterOrEqual (const T &v1, const U &v2) noexcept |
| | Determines whether the elements of v1 are greater than, or equal to, the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| auto | GreaterOrEqual (const T &v1, const U value) noexcept |
| | Determines whether the elements of v1 are greater than, or equal to, value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| auto | GreaterOrEqual (const T value, const U &v2) noexcept |
| | Determines whether value is greater than, or equal to, the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AllGreaterOrEqual (const T &v1, const U &v2) noexcept |
| | Determines whether all the elements of v1 are greater than, or equal to, the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AllGreaterOrEqual (const T &v1, const U value) noexcept |
| | Determines whether all the elements of v1 are greater than, or equal to, value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AllGreaterOrEqual (const T value, const U &v2) noexcept |
| | Determines whether value is greater than, or equal to, all of the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AnyGreaterOrEqual (const T &v1, const U &v2) noexcept |
| | Determines whether any of the elements of v1 are greater than, or equal to, the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AnyGreaterOrEqual (const T &v1, const U value) noexcept |
| | Determines whether any of the elements of v1 are greater than, or equal to, value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AnyGreaterOrEqual (const T value, const U &v2) noexcept |
| | Determines whether value is greater than, or equal to, any of the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | Greater (const T &v1, const U &v2) noexcept |
| | Determines whether the elements of v1 are greater than the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| auto | Greater (const T &v1, U value) noexcept |
| | Determines whether the elements of v1 are greater than value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| auto | Greater (T value, const U &v2) noexcept |
| | Determines whether value is greater than the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AllGreater (const T &v1, const U &v2) noexcept |
| | Determines whether all the elements of v1 are greater than the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AllGreater (const T &v1, U value) noexcept |
| | Determines whether all the elements of v1 are greater than value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AllGreater (T value, const U &v2) noexcept |
| | Determines whether value is greater than all of the elements of v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| bool | AnyGreater (const T &v1, const U &v2) noexcept |
| | Determines whether any of the elements of v1 are greater than the corresponding elements of v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| bool | AnyGreater (const T &v1, U value) noexcept |
| | Determines whether any of the elements of v1 are greater than value.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| bool | AnyGreater (T value, const U &v2) noexcept |
| | Determines whether value is greater than any of the elements of v2.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| S | Select (const S &v1, const T &v2, const U &control) noexcept |
| | Performs a per-component selection between two input vectors and returns the resulting vector.
|
| |
| template<SimdOrTupleType T> |
| auto | IsNaN (const T &t) noexcept |
| | Determines which of the elements of t are NaN.
|
| |
| template<SimdOrTupleType T> |
| auto | IsInf (const T &t) noexcept |
| | Determines which of the elements of t are Inf.
|
| |
| template<SimdOrTupleType T> |
| auto | Abs (const T &t) noexcept |
| | Computes the absolute value of each element held by the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | FastAbs (const T &t) noexcept |
| | Computes the absolute value of each element held by the argument.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | Min (const T &lhs, const U &rhs) noexcept |
| | Makes a comparison between the elements held by the two arguments, and returns a TupleSimd derived object containing the smallest elements.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<SimdOrTupleType T> |
| auto | Sqr (const T &t) noexcept |
| | Computes the square value of each element held by the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | Ceil (const T &t) noexcept |
| | Computes the ceiling of each element held by the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | Floor (const T &t) noexcept |
| | Computes the floor of each element held by the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | Round (const T &t) noexcept |
| | Rounds each element held by the argument towards the nearest even integer.
|
| |
| template<SimdOrTupleType T> |
| auto | Trunc (const T &t) noexcept |
| | Rounds each element held by the argument to the nearest integer in the direction of zero.
|
| |
template<SimdType T, SimdType U, ArithmeticType NumberT>
requires IsCompatible<T, U> |
| auto | Lerp (const T &a, const U &b, NumberT t) noexcept |
| | Calculates the linear interpolation between the the elements of a and the elements of b, for elements of t is inside [0,1), or the linear extrapolation for elements in t outside [0,1).
|
| |
template<SimdOrTupleType T, SimdOrTupleType U, ArithmeticType NumberT>
requires IsCompatible<T, U>&& Internal::HasTupleType<T, U> |
| auto | Lerp (const T &a, const U &b, NumberT t) noexcept |
| | Calculates the linear interpolation between the the elements of a and the elements of b, for elements of t is inside [0,1), or the linear extrapolation for elements in t outside [0,1).
|
| |
template<SimdType S, SimdType T, SimdType U>
requires IsCompatible<S, T, U> |
| auto | Lerp (const S &a, const T &b, const U &t) noexcept |
| | Calculates the linear interpolation between the the elements of a and the elements of b, for elements of t is inside [0,1), or the linear extrapolation for elements in t outside [0,1).
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U>&& Internal::HasTupleType<S, T, U> |
| auto | Lerp (const S &a, const T &b, const U &t) noexcept |
| | Calculates the linear interpolation between the the elements of a and the elements of b, for elements of t is inside [0,1), or the linear extrapolation for elements in t outside [0,1).
|
| |
| template<ArithmeticType NumberT1, ArithmeticType NumberT2, SimdOrTupleType T> |
| auto | Lerp (const NumberT1 a, const NumberT2 b, const T &t) noexcept |
| | Calculates the linear interpolation between a and b, for elements of t is inside [0,1), or the linear extrapolation for elements in t outside [0,1).
|
| |
template<ArithmeticType S, SimdType T, SimdType U>
requires IsCompatible<T, U> |
| auto | Lerp2 (const S t, const T &a, const U &b) noexcept |
| | Calculates the linear interpolation between the the elements of a and the elements of b, for elements of t is inside [0,1), or the linear extrapolation for elements in t outside [0,1).
|
| |
template<ArithmeticType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U>&& Internal::HasTupleType<T, U> |
| auto | Lerp2 (const S t, const T &a, const U &b) noexcept |
| | Calculates the linear interpolation between the the elements of a and the elements of b, for elements of t is inside [0,1), or the linear extrapolation for elements in t outside [0,1).
|
| |
template<SimdType S, SimdType T, SimdType U>
requires IsCompatible<S, T, U> |
| auto | Lerp2 (const S &t, const T &a, const U &b) noexcept |
| | Calculates the linear interpolation between the the elements of a and the elements of b, for elements of t is inside [0,1), or the linear extrapolation for elements in t outside [0,1).
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U>&& Internal::HasTupleType<S, T, U> |
| auto | Lerp2 (const S &t, const T &a, const U &b) noexcept |
| | Calculates the linear interpolation between the the elements of a and the elements of b, for elements of t is inside [0,1), or the linear extrapolation for elements in t outside [0,1).
|
| |
| template<SimdType S, ArithmeticType T, ArithmeticType U> |
| auto | Lerp2 (const S &t, const T a, const U b) noexcept |
| | Calculates the linear interpolation between a and b, for elements of t is inside [0,1), or the linear extrapolation for elements in t outside [0,1).
|
| |
| template<int shuffleMask, SimdOrTupleType T> |
| T | Permute (const T &t) noexcept |
| |
template<SimdType S, SimdType T, SimdType U>
requires IsCompatible<S, T, U> |
| auto | 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 by the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U>&& Internal::HasTupleType<S, T, U> |
| auto | 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 by the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.
|
| |
| template<SimdType S, ArithmeticType T, ArithmeticType U> |
| auto | 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 by lowerBounds and upperBounds, otherwise the value of nearest boundary is returned.
|
| |
template<ArithmeticType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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 by the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.
|
| |
| template<SimdOrTupleType S> |
| auto | ClampZero (const S &v) noexcept |
| |
template<SimdOrTupleType S, SimdOrTupleType T>
requires IsCompatible<S, T> |
| auto | InBounds (const S &v, const T &bounds) noexcept |
| | Detects if the elements of a vector are within bounds.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| auto | ClampLength (const S &v, const T &lengthMin, const U &lengthMax) noexcept |
| | Clamps the length of a vector to a given range.
|
| |
| template<SimdOrTupleType S, ArithmeticType T, ArithmeticType U> |
| auto | ClampLength (const S &v, const T lengthMin, const U lengthMax) noexcept |
| | Clamps the length of a vector to a given range.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T>
requires IsCompatible<S, T> |
| auto | Reflect (const S &incident, const T &normal) noexcept |
| | Reflects an incident vector across a normal vector.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| auto | Refract (const S &incident, const T &normal, const U &refractionIndex) noexcept |
| | Refracts an incident vector across a normal vector.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, ArithmeticType U>
requires IsCompatible<S, T> |
| auto | Refract (const S &incident, const T &normal, const U refractionIndex) noexcept |
| | Refracts an incident vector across a normal vector.
|
| |
| template<SimdOrTupleType S> |
| auto | Orthogonal (const S &v) noexcept |
| | Computes a vector perpendicular to the argument vector.
|
| |
| template<SimdOrTupleType T> |
| auto | Saturate (const T &v) noexcept |
| | Saturates the elements of v to the range 0.0 to 1.0.
|
| |
| template<SimdOrTupleType T> |
| auto | Sqrt (const T &v) noexcept |
| | Calculates the square root of each element in the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | Cbrt (const T &v) noexcept |
| | Calculates the cube root of each element in the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | SafeSqrt (const T &v) noexcept |
| | Calculates the square root of each element greater or equal to 0.f in the argument. For elements less than 0.f, the result is 0.f.
|
| |
| template<SimdOrTupleType T> |
| auto | ReciprocalSqrt (const T &v) noexcept |
| | Calculates the reciprocal square root of each element in the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | Reciprocal (const T &t) noexcept |
| | Calculates the reciprocal of each element in the argument.
|
| |
template<SimdType S, SimdType T, SimdType U>
requires IsCompatible<S, T, U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U>&& Internal::HasTupleType<S, T, U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, ArithmeticType U>
requires IsCompatible<S, T> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, SimdOrTupleType U>
requires IsCompatible<S, U> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, ArithmeticType T, SimdOrTupleType U> |
| auto | 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<SimdType T, typename C >
requires IsArithmetic<C> |
| constexpr T | EvaluatePolynomial (const T &t, C c) |
| | Evaluates the provided polynomial using Horner’s method.
|
| |
template<SimdType T, SimdType C>
requires IsCompatible<T, C> |
| constexpr T | EvaluatePolynomial (const T &t, C c) |
| |
template<SimdType T, typename C , typename... Args>
requires IsArithmetic<C> |
| constexpr T | EvaluatePolynomial (const T &t, C c, Args... remaining) |
| |
template<TupleType T, typename C , typename... Args>
requires IsArithmetic<C> |
| constexpr T::Simd | EvaluatePolynomial (const T &t, C c, Args... remaining) |
| |
template<SimdType T, SimdType C, typename... Args>
requires IsCompatible<T, C> |
| constexpr T | EvaluatePolynomial (const T &t, const C &c, Args... remaining) |
| |
template<TupleType T, SimdType C, typename... Args>
requires IsCompatible<T, C> |
| constexpr T::Simd | EvaluatePolynomial (const T &t, const C &c, Args... remaining) |
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, ArithmeticType U>
requires IsCompatible<S, T> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, SimdOrTupleType U>
requires IsCompatible<S, U> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, ArithmeticType T, SimdOrTupleType U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, ArithmeticType U>
requires IsCompatible<S, T> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, SimdOrTupleType U>
requires IsCompatible<S, U> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, ArithmeticType T, SimdOrTupleType U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, ArithmeticType U>
requires IsCompatible<S, T> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, SimdOrTupleType U>
requires IsCompatible<S, U> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, ArithmeticType T, SimdOrTupleType U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, ArithmeticType U>
requires IsCompatible<S, T> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, SimdOrTupleType U>
requires IsCompatible<S, U> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, ArithmeticType T, SimdOrTupleType U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, ArithmeticType U>
requires IsCompatible<S, T> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, SimdOrTupleType U>
requires IsCompatible<S, U> |
| auto | 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<SimdOrTupleType S, ArithmeticType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<ArithmeticType S, SimdOrTupleType T, ArithmeticType U> |
| auto | 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<ArithmeticType S, ArithmeticType T, SimdOrTupleType U> |
| auto | 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<SimdOrTupleType T> |
| auto | Sin (const T &v) noexcept |
| | Calculates the sine of each element in the argument expressed in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | FastSin (const T &v) noexcept |
| | Calculates the sine of each element in the argument expressed in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | Cos (const T &v) noexcept |
| | Calculates the cosine of each element in the argument expressed in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | FastCos (const T &v) noexcept |
| | Calculates the cosine of each element in the argument expressed in radians.
|
| |
| template<SimdType T> |
| T | SinCos (const T &v, T *cosines) noexcept |
| | Calculates the sine and cosine of each element in the argument expressed in radians.
|
| |
| template<TupleType T> |
| T::Simd | SinCos (const T &v, typename T::Simd *cosines) noexcept |
| | Calculates the sine and cosine of each element in the argument expressed in radians.
|
| |
| template<SimdType T> |
| T | FastSinCos (const T &v, T *cosines) noexcept |
| | Calculates the sine and cosine of each element in the argument expressed in radians.
|
| |
| template<TupleType T> |
| T::Simd | FastSinCos (const T &v, typename T::Simd *cosines) noexcept |
| | Calculates the sine and cosine of each element in the argument expressed in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | Tan (const T &v) noexcept |
| | Calculates the tangent of each element in the argument expressed in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | FastTan (const T &v) noexcept |
| | Calculates the tangent of each element in the argument expressed in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | ASin (const T &v) noexcept |
| | Calculates the inverse sine of each element in the argument, in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | ACos (const T &v) noexcept |
| | Calculates the inverse cosine of each element in the argument, in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | ATan (const T &v) noexcept |
| | Calculates the inverse tangent of each element in the argument, in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | FastATan (const T &v) noexcept |
| | Calculates the inverse tangent of each element in the argument, in radians.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | FastATan2 (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<SimdOrTupleType T> |
| auto | ModAngles (const T &angles) |
| | Calculates the angle modulo 2PI.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<SimdOrTupleType T> |
| auto | SinH (const T &v) noexcept |
| | Calculates the hyperbolic sine of each element in the argument expressed in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | CosH (const T &v) noexcept |
| | Calculates the hyperbolic cosine of each element in the argument expressed in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | TanH (const T &v) noexcept |
| | Calculates the hyperbolic tangent of each element in the argument expressed in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | ASinH (const T &v) noexcept |
| | Calculates the inverse hyperbolic sine of each element in the argument, in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | ACosH (const T &v) noexcept |
| | Calculates the inverse hyperbolic cosine of each element in the argument, in radians.
|
| |
| template<SimdOrTupleType T> |
| auto | ATanH (const T &v) noexcept |
| | Calculates the inverse hyperbolic tangent of each element in the argument, in radians.
|
| |
| template<SimdType T> |
| auto | Log (const T &v) noexcept |
| | Calculates the natural logarithm of each element in the argument.
|
| |
| template<SimdType T> |
| auto | Log1P (const T &v) noexcept |
| | Calculates the natural logarithm of 1 + each element in the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | Log10 (const T &v) noexcept |
| | Calculates the base-10 logarithm of each element in the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | Log2 (const T &v) noexcept |
| | Calculates the base-2 logarithm, $$log_{2}_$$, of each element in the argument.
|
| |
| template<SimdType T> |
| auto | Exp (const T &v) noexcept |
| | Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | Exp10 (const T &v) noexcept |
| | Calculates the base-10 exponential of each element in the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | Exp2 (const T &v) noexcept |
| | Calculates the base-2 exponential of each element in the argument.
|
| |
| template<SimdOrTupleType T> |
| auto | 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<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | Pow (const T &base, const U &exponent) noexcept |
| | Calculates the elements in base raised to the corresponding element in exponent.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| auto | Pow (const T &base, const U exponent) noexcept |
| | Calculates the elements in base raised to the value of exponent.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| auto | Pow (const T &base, const U &exponent) noexcept |
| | Returns the value of base raised to the corresponding elements in exponent.
|
| |
| template<int n, SimdType T> |
| T | FastPow (const T &v) |
| |
| template<int n, TupleType T> |
| T::Simd | FastPow (const T &v) |
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | FMod (const T &x, const U &y) noexcept |
| | Computes the floating-point remainder of the division operation $x/y$.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| auto | FMod (const T &x, const U y) noexcept |
| | Computes the floating-point remainder of the division operation $x/y$.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| auto | FMod (const T x, const U &y) noexcept |
| | Computes the floating-point remainder of the division operation $x/y$.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | 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<SimdOrTupleType T, ArithmeticType U> |
| auto | 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<ArithmeticType T, SimdOrTupleType U> |
| auto | 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<SimdOrTupleType T, SimdOrTupleType U, SimdOrTupleType V, SimdOrTupleType W, ArithmeticType X>
requires IsCompatible<T, U, V, W> |
| auto | Hermite (const T &firstPosition, const U &firstTangent, const V &secondPosition, const W &secondTangent, const X t) noexcept |
| | Calculates the Hermite spline interpolation, using the specified arguments.
|
| |
template<SimdType T, SimdType U>
requires IsCompatible<T, U> |
| auto | Dot (const T &v1, const U &v2) noexcept |
| | Calculates the dot product between v1 and v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U>&& Internal::HasSimdType<T, U>&& Internal::HasTupleType<T, U> |
| auto | Dot (const T &v1, const U &v2) noexcept |
| | Calculates the dot product between v1 and v2.
|
| |
| template<SimdOrTupleType T, ArithmeticType U> |
| auto | Dot (const T &v1, const U v2) noexcept |
| | Calculates the dot product between v1 and v2.
|
| |
| template<ArithmeticType T, SimdOrTupleType U> |
| auto | Dot (const T v1, const U &v2) noexcept |
| | Calculates the dot product between v1 and v2.
|
| |
template<TupleType T, TupleType U>
requires IsCompatible<T, U> |
| constexpr T::Simd | Dot (const T &v1, const U &v2) noexcept |
| |
template<int mask, SimdType T, SimdType U>
requires IsCompatible<T, U> |
| auto | Dot (const T &v1, const U &v2) noexcept |
| | Calculates the dot product between v1 and v2.
|
| |
template<int mask, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U>&& Internal::HasSimdType<T, U>&& Internal::HasTupleType<T, U> |
| auto | Dot (const T &v1, const U &v2) noexcept |
| | Calculates the dot product between v1 and v2.
|
| |
| template<int mask, SimdOrTupleType T, ArithmeticType U> |
| auto | Dot (const T &v1, const U v2) noexcept |
| | Calculates the dot product between v1 and v2.
|
| |
| template<int mask, ArithmeticType T, SimdOrTupleType U> |
| auto | Dot (const T v1, const U &v2) noexcept |
| | Calculates the dot product between v1 and v2.
|
| |
template<SimdType T, SimdType U>
requires IsCompatible<T, U> |
| constexpr T::value_type | ScalarDot (const T &v1, const U &v2) noexcept |
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | AbsDot (const T &v1, const U &v2) noexcept |
| | Calculates the absolute value of the dot product between v1 and v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires 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<SimdType T, SimdType U>
requires IsCompatible<T, U> |
| auto | Cross (const T &v1, const U &v2) noexcept |
| | Calculates the cross product between v1 and v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U>&& Internal::HasTupleType<T, U> |
| auto | Cross (const T &v1, const U &v2) noexcept |
| | Calculates the cross product between v1 and v2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | UnitCross (const T &v1, const U &v2) noexcept |
| | Calculates the normalized cross product between v1 and v2.
|
| |
| template<SimdType T> |
| auto | LengthSquared (const T &v) noexcept |
| | Calculates the squared length of v.
|
| |
| template<SimdType T> |
| auto | ScalarLengthSquared (const T &q) noexcept |
| | Calculates the square of the magnitude of a quaternion.
|
| |
| template<SimdOrTupleType T> |
| auto | Length (const T &v) noexcept |
| | Calculates the length of v.
|
| |
| template<SimdOrTupleType T> |
| auto | ScalarLength (const T &v) noexcept |
| | Calculates the length of v.
|
| |
| template<SimdOrTupleType T> |
| auto | Normalize (const T &v) noexcept |
| | Normalizes v.
|
| |
| template<SimdOrTupleType T> |
| auto | ReciprocalLength (const T &v) noexcept |
| | Calculates the reciprocal length of v.
|
| |
| template<SimdOrTupleType T> |
| auto | ScalarReciprocalLength (const T &v) noexcept |
| | Calculates the reciprocal length of v.
|
| |
template<SimdType T, SimdType U>
requires IsCompatible<T, U> |
| auto | DistanceSquared (const T &p1, const U &p2) noexcept |
| | Calculates the squared distance between p1 and p2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U>&& Internal::HasTupleType<T, U> |
| auto | DistanceSquared (const T &p1, const U &p2) noexcept |
| | Calculates the squared distance between p1 and p2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U>&& Internal::HasSimdType<T, U> |
| auto | ScalarDistanceSquared (const T &p1, const U &p2) noexcept |
| | Calculates the squared distance between p1 and p2.
|
| |
template<TupleType T, TupleType U>
requires IsCompatible<T, U> |
| constexpr auto | ScalarDistanceSquared (const T &p1, const U &p2) noexcept |
| | Calculates the squared distance between p1 and p2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | Distance (const T &p1, const U &p2) noexcept |
| | Calculates the distance between p1 and p2.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> |
| auto | ScalarDistance (const T &p1, const U &p2) noexcept |
| |
| template<SimdTupleOrArithmeticType S, SimdOrTupleType T, SimdTupleOrArithmeticType U, SimdTupleOrArithmeticType V> |
| auto | 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<SimdTupleOrArithmeticType S, SimdOrTupleType T, SimdTupleOrArithmeticType U, SimdTupleOrArithmeticType V> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U, SimdOrTupleType V, SimdOrTupleType W>
requires IsCompatible<S, T>&& IsCompatible<S, U>&& IsCompatible<S, V>&& IsCompatible<S, W> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U, ArithmeticType V, ArithmeticType W>
requires IsCompatible<S, T, U> |
| auto | 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<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U, SimdOrTupleType V, SimdOrTupleType W>
requires IsCompatible<S, T, U, V, 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<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U, SimdOrTupleType V, ArithmeticType W>
requires IsCompatible<S, T, U, V> |
| auto | 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<SimdType T> |
| auto | MinComponentValue (const T &v) noexcept |
| | Retrieves the lowest value held by the argument.
|
| |
| template<TupleType T> |
| constexpr auto | MinComponentValue (const T &v) noexcept |
| | Retrieves the lowest value held by the argument.
|
| |
| template<SimdType T> |
| auto | MaxComponentValue (const T &v) noexcept |
| | Retrieves the highest value held by the argument.
|
| |
| template<TupleType T> |
| constexpr auto | MaxComponentValue (const T &v) noexcept |
| | Retrieves the highest value held by the argument.
|
| |
| template<TupleType T> |
| constexpr size_t | MaxComponentIndex (const T &v) noexcept |
| | Retrieves the offset of the highest value held by the argument.
|
| |
| template<TupleType T> |
| constexpr size_t | MinComponentIndex (const T &v) noexcept |
| | Retrieves the offset of the lowest value held by the argument.
|
| |
| template<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<SimdOrTupleType T> |
| auto | NextUp (const T &t) noexcept |
| |
| template<SimdOrTupleType T> |
| auto | NextDown (const T &t) noexcept |
| |
template<SimdType S, SimdType T>
requires IsCompatible<S, T> |
| S | AddAdjustUp (const S &a, const T &b) noexcept |
| |
template<TupleType S, SimdType T>
requires IsCompatible<S, T> |
| T | AddAdjustUp (const S &a, const T &b) noexcept |
| |
template<TupleType S, TupleType T>
requires IsCompatible<S, T> |
| S::Simd | AddAdjustUp (const S &a, const T &b) noexcept |
| |
template<SimdType S, SimdType T>
requires IsCompatible<S, T> |
| S | AddAdjustDown (const S &a, const T &b) noexcept |
| |
template<TupleType S, SimdType T>
requires IsCompatible<S, T> |
| T | AddAdjustDown (const S &a, const T &b) noexcept |
| |
template<TupleType S, TupleType T>
requires IsCompatible<S, T> |
| S::Simd | AddAdjustDown (const S &a, const T &b) noexcept |
| |
template<SimdType S, SimdType T>
requires IsCompatible<S, T> |
| S | SubAdjustUp (const S &a, const T &b) noexcept |
| |
template<TupleType S, SimdType T>
requires IsCompatible<S, T> |
| T | SubAdjustUp (const S &a, const T &b) noexcept |
| |
template<TupleType S, TupleType T>
requires IsCompatible<S, T> |
| S::Simd | SubAdjustUp (const S &a, const T &b) noexcept |
| |
template<SimdType S, SimdType T>
requires IsCompatible<S, T> |
| S | SubAdjustDown (const S &a, const T &b) noexcept |
| |
template<TupleType S, SimdType T>
requires IsCompatible<S, T> |
| T | SubAdjustDown (const S &a, const T &b) noexcept |
| |
template<TupleType S, TupleType T>
requires IsCompatible<S, T> |
| S::Simd | SubAdjustDown (const S &a, const T &b) noexcept |
| |
template<SimdType S, SimdType T>
requires IsCompatible<S, T> |
| S | MulAdjustUp (const S &a, const T &b) noexcept |
| |
template<TupleType S, SimdType T>
requires IsCompatible<S, T> |
| T | MulAdjustUp (const S &a, const T &b) noexcept |
| |
template<TupleType S, TupleType T>
requires IsCompatible<S, T> |
| S::Simd | MulAdjustUp (const S &a, const T &b) noexcept |
| |
template<SimdType S, SimdType T>
requires IsCompatible<S, T> |
| S | MulAdjustDown (const S &a, const T &b) noexcept |
| |
template<TupleType S, SimdType T>
requires IsCompatible<S, T> |
| T | MulAdjustDown (const S &a, const T &b) noexcept |
| |
template<TupleType S, TupleType T>
requires IsCompatible<S, T> |
| S::Simd | MulAdjustDown (const S &a, const T &b) noexcept |
| |
template<SimdType S, SimdType T>
requires IsCompatible<S, T> |
| S | DivAdjustUp (const S &a, const T &b) noexcept |
| |
template<TupleType S, SimdType T>
requires IsCompatible<S, T> |
| T | DivAdjustUp (const S &a, const T &b) noexcept |
| |
template<TupleType S, TupleType T>
requires IsCompatible<S, T> |
| S::Simd | DivAdjustUp (const S &a, const T &b) noexcept |
| |
template<SimdType S, SimdType T>
requires IsCompatible<S, T> |
| S | DivAdjustDown (const S &a, const T &b) noexcept |
| |
template<TupleType S, SimdType T>
requires IsCompatible<S, T> |
| T | DivAdjustDown (const S &a, const T &b) noexcept |
| |
template<TupleType S, TupleType T>
requires IsCompatible<S, T> |
| S::Simd | DivAdjustDown (const S &a, const T &b) noexcept |
| |
| template<SimdType S> |
| S | SqrtAdjustUp (const S &v) noexcept |
| |
| template<TupleType S> |
| S::Simd | SqrtAdjustUp (const S &v) noexcept |
| |
| template<SimdType S> |
| S | SqrtAdjustDown (const S &v) noexcept |
| |
| template<TupleType S> |
| S::Simd | SqrtAdjustDown (const S &v) noexcept |
| |
template<typename NumberT , SimdType T, SimdType U>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| T | FMAAdjustUp (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 , TupleType T, SimdType U>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| U | FMAAdjustUp (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 , TupleType T, TupleType U, typename ResultT = typename T::Simd>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| ResultT | FMAAdjustUp (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 , SimdType T, SimdType U>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| T | FMAAdjustUp (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 , TupleType T, SimdType U>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| U | FMAAdjustUp (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 , TupleType T, TupleType U, typename ResultT = typename T::Simd>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| ResultT | FMAAdjustUp (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<SimdType S, SimdType T, SimdType U>
requires IsCompatible<S, T>&& IsCompatible<T, U> |
| T | FMAAdjustUp (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<SimdType S, TupleType T, SimdType U>
requires IsCompatible<S, T>&& IsCompatible<T, U> |
| U | FMAAdjustUp (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<SimdType S, TupleType T, TupleType U>
requires IsCompatible<S, T>&& IsCompatible<T, U> |
| S | FMAAdjustUp (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<TupleType S, TupleType T, TupleType U, typename ResultT = typename T::Simd>
requires IsCompatible<S, T>&& IsCompatible<T, U> |
| ResultT | FMAAdjustUp (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 , SimdType T, SimdType U>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| T | FMAAdjustDown (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 , TupleType T, SimdType U>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| U | FMAAdjustDown (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 , TupleType T, TupleType U, typename ResultT = typename T::Simd>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| ResultT | FMAAdjustDown (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 , SimdType T, SimdType U>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| T | FMAAdjustDown (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 , TupleType T, SimdType U>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| U | FMAAdjustDown (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 , TupleType T, TupleType U, typename ResultT = typename T::Simd>
requires std::is_arithmetic_v<NumberT>&& IsCompatible<T, U> |
| ResultT | FMAAdjustDown (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<SimdType S, SimdType T, SimdType U>
requires IsCompatible<S, T>&& IsCompatible<T, U> |
| T | FMAAdjustDown (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<SimdType S, TupleType T, SimdType U>
requires IsCompatible<S, T>&& IsCompatible<T, U> |
| U | FMAAdjustDown (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<SimdType S, TupleType T, TupleType U>
requires IsCompatible<S, T>&& IsCompatible<T, U> |
| S | FMAAdjustDown (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<TupleType S, TupleType T, TupleType U, typename ResultT = typename T::Simd>
requires IsCompatible<S, T>&& IsCompatible<T, U> |
| ResultT | FMAAdjustDown (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<VectorOrVectorSimdType S, VectorOrVectorSimdType T>
requires IsCompatible<S, T> |
| auto | AngleBetween (const S &v1, const T &v2) noexcept |
| | Calculates the angle in radians between two vectors.
|
| |
template<VectorOrVectorSimdType S, VectorOrVectorSimdType T>
requires IsCompatible<S, T> |
| auto | AngleBetweenNormalized (const S &v1, const T &v2) noexcept |
| | Calculates the angle in radians between two normalized vectors.
|
| |
| Point2f | InvertBilinear (const Point2f &p, const std::array< Point2f, 4 > &vert) |
| |
template<PointOrPointSimdType S, PointOrPointSimdType T, PointOrPointSimdType U>
requires IsCompatible<S, T>&& IsCompatible<S, U> |
| auto | LinePointDistance (const S &linePoint1, const T &linePoint2, const U &point) noexcept |
| | Calculates the minimum distance between a line and a point.
|
| |
template<QuaternionOrQuaternionSimdType T, QuaternionOrQuaternionSimdType U>
requires IsCompatibleQuaternion<T, U> |
| auto | operator+ (const T &q1, const U &q2) noexcept |
| |
template<QuaternionOrQuaternionSimdType T, QuaternionOrQuaternionSimdType U>
requires IsCompatibleQuaternion<T, U> |
| auto | operator- (const T &q1, const U &q2) noexcept |
| |
template<QuaternionOrQuaternionSimdType T, QuaternionOrQuaternionSimdType U>
requires IsCompatibleQuaternion<T, U> |
| auto | operator* (const T &q1, const U &q2) noexcept |
| |
template<QuaternionOrQuaternionSimdType T, QuaternionOrQuaternionSimdType U>
requires IsCompatibleQuaternion<T, U> |
| auto | Dot (const T &q1, const U &q2) noexcept |
| | Calculates the dot product of two quaternions.
|
| |
template<QuaternionOrQuaternionSimdType T, QuaternionOrQuaternionSimdType U>
requires IsCompatibleQuaternion<T, U> |
| auto | ScalarDot (const T &q1, const U &q2) noexcept |
| | Calculates the dot product of two quaternions.
|
| |
| template<QuaternionOrQuaternionSimdType T> |
| auto | Conjugate (const T &q) noexcept |
| | Calculates the conjugate of a quaternion.
|
| |
| template<QuaternionOrQuaternionSimdType T> |
| auto | Inverse (const T &q) noexcept |
| | Calculates the inverse of a quaternion.
|
| |
template<QuaternionOrQuaternionSimdType T, QuaternionOrQuaternionSimdType U, SimdOrTupleType V>
requires IsCompatibleQuaternion<T, U> && ( V::Size == 4 ) |
| auto | Slerp (const T &q1, const U &q2, const V &t) noexcept |
| | Spherical linear interpolation between two unit quaternions.
|
| |
template<QuaternionOrQuaternionSimdType T, QuaternionOrQuaternionSimdType U, ArithmeticType V>
requires IsCompatibleQuaternion<T, U> |
| auto | Slerp (const T &q1, const U &q2, const V t) noexcept |
| | Spherical linear interpolation between two unit quaternions.
|
| |
template<SimdOrTupleType S, QuaternionOrQuaternionSimdType T>
requires ( S::Size == 3 ) |
| auto | Rotate (const S &v, const T &rotationQuaternion) |
| | Rotates a vector using a quaternion.
|
| |
template<SimdOrTupleType S, QuaternionOrQuaternionSimdType T>
requires ( S::Size == 3 ) |
| S | InverseRotate (const S &v, const T &rotationQuaternion) |
| | Rotates a vector using the inverse of a quaternion.
|
| |
template<SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<T, U> && ( T::Size == 3 ) |
| auto | ShortestArc (const T &fromDir, const U &toDir) noexcept |
| | Creates the shortest-arc rotation between two directions.
|
| |
template<SimdType T, SimdType U>
requires 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<SquareMatrixSimdType T1, SquareMatrixSimdType T2>
requires IsCompatibleMatrix<T1, T2> |
| auto | operator+ (const T1 &m1, const T2 &m2) noexcept |
| |
template<SquareMatrixOrSquareMatrixSimdType T1, SquareMatrixOrSquareMatrixSimdType T2>
requires IsCompatibleMatrix<T1, T2>&& Internal::HasSquareMatrixType<T1, T2> |
| auto | operator+ (const T1 &m1, const T2 &m2) noexcept |
| |
template<SquareMatrixSimdType T1, SquareMatrixSimdType T2>
requires IsCompatibleMatrix<T1, T2> |
| auto | operator- (const T1 &m1, const T2 &m2) noexcept |
| |
template<SquareMatrixOrSquareMatrixSimdType T1, SquareMatrixOrSquareMatrixSimdType T2>
requires IsCompatibleMatrix<T1, T2>&& Internal::HasSquareMatrixType<T1, T2> |
| auto | operator- (const T1 &m1, const T2 &m2) noexcept |
| |
| template<SquareMatrixSimdType T1, ArithmeticType T2> |
| auto | operator* (const T1 &m, const T2 value) noexcept |
| |
| template<ArithmeticType T1, SquareMatrixSimdType T2> |
| auto | operator* (const T1 value, const T2 &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<SquareMatrixSimdType T1, SquareMatrixSimdType T2>
requires IsCompatibleMatrix<T1, T2> |
| T2 | operator* (const T1 &m1, const T2 &m2) noexcept |
| |
template<SquareMatrixOrSquareMatrixSimdType T1, SquareMatrixOrSquareMatrixSimdType T2>
requires IsCompatibleMatrix<T1, T2>&& Internal::HasSquareMatrixType<T1, T2> |
| T2 | operator* (const T1 &m1, const T2 &m2) noexcept |
| |
| template<SquareMatrixSimdType T1, ArithmeticType T2> |
| auto | 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<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.
|
| |
| 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<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<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.
|
| |
| 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<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<SimdOrTupleType 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 Quaternion< float >::Simd &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 Quaternion< float >::Simd &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.
|
| |
template<PointOrPointSimdType PointT, QuaternionOrQuaternionSimdType QuaternionT, VectorOrVectorSimdType VectorT>
requires ( PointT::Size == 3 ) && ( VectorT::Size == 3 ) && std::is_same_v<typename PointT::value_type, typename QuaternionT::value_type>&& std::is_same_v<typename PointT::value_type, typename VectorT::value_type> |
| SquareMatrix< typenamePointT::value_type, 4 >::Simd | TransformationMatrix (const PointT &scalingOrigin, const QuaternionT &scalingOrientationQuaternion, const VectorT &scaling, const PointT &rotationOrigin, const QuaternionT &rotationQuaternion, const VectorT &translation) noexcept |
| | Creates a transformation matrix.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, QuaternionOrQuaternionSimdType U, SimdOrTupleType W>
requires ( S::Size > 2 ) && ( T::Size > 2 ) && ( W::Size > 2 ) && std::is_same_v<typename S::value_type, typename T::value_type>&& std::is_same_v<typename S::value_type, typename U::value_type>&& std::is_same_v<typename S::value_type, typename W::value_type> |
| SquareMatrix< typenameS::value_type, 4 >::Simd | AffineTransformationMatrix (const S &scaling, const T &rotationOrigin, const U &rotationQuaternion, const W &translation) noexcept |
| | Creates an affine transformation matrix.
|
| |
template<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, 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<SimdOrTupleType S, SimdOrTupleType T, SimdOrTupleType U>
requires IsCompatible<S, T, 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::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.
|
| |
| template<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.
|
| |
| bool | Decompose (const SquareMatrix< float, 4 >::Simd &matrix, Vector3f::Simd *outScale, Quaternion< float >::Simd *outRotQuat, Vector3f::Simd *outTrans) noexcept |
| |
| template<PlaneSimdType T> |
| T | Normalize (const T &plane) noexcept |
| |
| template<PlaneType T> |
| T::Simd | Normalize (const T &plane) noexcept |
| |
| template<PlaneSimdType T> |
| T | FastNormalize (const T &plane) noexcept |
| |
| template<PlaneType T> |
| T::Simd | FastNormalize (const T &plane) noexcept |
| |
template<PlaneSimdType P, VectorSimdType V>
requires std::is_same_v<typename P::value_type, typename V::value_type> && ( V::Size > 2 ) |
| V | Dot (const P &plane, const V &v) |
| |
template<PlaneSimdType P, NormalSimdType N>
requires std::is_same_v<typename P::value_type, typename N::value_type> && ( N::Size > 2 ) |
| N | Dot (const P &plane, const N &normal) |
| |
| template<PlaneSimdType P, PointSimdType PT> |
| PT | Dot (const P &plane, const PT &point) |
| |
| template<Internal::VectorNormalOrPointSimdType T, PlaneSimdType P> |
| T | Dot (const T &v, const P &plane) |
| |
| template<PlaneType P, Internal::VectorNormalOrPointType T> |
| T | Dot (const P &plane, const T &v) |
| |
| template<PlaneType P, PointSimdType PT> |
| PT | Intersect (const P &plane, const PT &linePoint1, const PT &linePoint2) noexcept |
| |
| std::pair< Point3f::Simd, Point3f::Simd > | Intersect (const Plane< float >::Simd &plane1, const Plane< float >::Simd &plane2) noexcept |
| |
| Plane< float >::Simd | Transform (const Plane< float >::Simd &plane, const SquareMatrix< float, 4 >::Simd &transformationMatrix) noexcept |
| |
| template<typename CharT , size_t N> |
| auto | operator<< (std::basic_ostream< CharT > &os, const SquareMatrix< float, N > &value) |
| |
| 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 |
| |
1.12.0