Harlinn.Windows 0.1
Loading...
Searching...
No Matches
Harlinn::Common::Core::Math Namespace Reference

Namespaces

namespace  Internal
 

Classes

class  BiasedExponent
 Holds the value of the biased exponent part of a floating point value. More...
 
class  CompensatedFloat
 
class  CompensatedSum
 
struct  Constants
 
struct  Constants< double >
 
struct  Constants< float >
 
class  Exponent
 Holds the value of the exponent part of a floating point value. More...
 
struct  FloatingPoint
 A template for encoding and decoding floating point values. More...
 
class  Interval
 
class  Normal3f
 
class  NormalizedFloat
 
class  Point2f
 
class  Point2i
 
class  Point3f
 
class  Point3i
 
class  Quaternion
 
class  QuaternionSimd
 
class  Scalar
 
class  Scalar< double, 2 >
 
class  Scalar< double, 3 >
 
class  Scalar< double, 4 >
 
class  Scalar< float, 2 >
 
class  Scalar< float, 3 >
 
class  Scalar< float, 4 >
 
class  Significand
 Holds the value of the significand part of a floating point value. More...
 
class  SquareMatrix
 
struct  SquareMatrixSimd
 
struct  SquareMatrixSimd< MatrixT, 1 >
 
struct  SquareMatrixSimd< MatrixT, 2 >
 
struct  SquareMatrixSimd< MatrixT, 3 >
 
struct  SquareMatrixSimd< MatrixT, 4 >
 
class  Transformation
 
class  Tuple2
 A tuple holding two numbers. More...
 
class  Tuple3
 
class  Tuple4
 
class  TupleSimd
 
class  Vector
 
class  Vector< double, 2 >
 
class  Vector< double, 3 >
 
class  Vector< double, 4 >
 
class  Vector< float, 2 >
 
class  Vector< float, 3 >
 
class  Vector< float, 4 >
 
class  Vector< Int32, 2 >
 
class  Vector< Int32, 3 >
 
class  Vector< Int32, 4 >
 
class  Vector< UInt32, 2 >
 
class  Vector< UInt32, 3 >
 
class  Vector< UInt32, 4 >
 

Concepts

concept  FloatingPointType
 
concept  VectorType
 
concept  VectorSimdType
 
concept  ScalarType
 
concept  ScalarSimdType
 
concept  PointType
 
concept  PointSimdType
 
concept  NormalType
 
concept  NormalSimdType
 

Typedefs

using Vector2f = Vector<float,2>
 
using Vector2i = Vector<int,2>
 
using Vector3f = Vector<float,3>
 
using Vector3i = Vector<int, 3>
 

Enumerations

enum class  MatrixType : UInt32 {
  Zero ,
  Identity
}
 

Functions

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

Variables

template<typename T >
constexpr bool IsLoadedType = T::Loaded
 
template<typename T >
constexpr bool IsUnloadedType = T::Unloaded
 

Typedef Documentation

◆ Vector2f

◆ Vector2i

◆ Vector3f

◆ Vector3i

Enumeration Type Documentation

◆ MatrixType

Enumerator
Zero 
Identity 

Function Documentation

◆ Abs() [1/6]

template<typename FloatT >
requires IsFloatingPoint<FloatT>
Interval< FloatT > Harlinn::Common::Core::Math::Abs ( const Interval< FloatT > & i)
inline

◆ Abs() [2/6]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::Abs ( const T & t)
inlinenoexcept

Computes the absolute value of each element held by the argument.

◆ Abs() [3/6]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::Abs ( const T & t)
inlinenoexcept

Computes the absolute value of each element held by the argument.

◆ Abs() [4/6]

template<typename T >
requires IsSignedInteger<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Abs ( T val)
inlineconstexprnoexcept

Computes the absolute value of a signed integer number. The behavior is undefined if the result cannot be represented by the return type.

In 2's complement systems, the absolute value of the most-negative value is out of range, e.g. for 32-bit 2's complement type int, INT_MIN is -2147483648, but the would-be result 2147483648 is greater than INT_MAX, which is 2147483647.

Template Parameters
TAny signed integer type.
Parameters
valA signed integer value.
Returns
The absolute value of val.

◆ Abs() [5/6]

template<typename T >
requires IsUnsignedInteger<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Abs ( T val)
inlineconstexprnoexcept

The absolute value of any unsigned integer is the same as its value.

Template Parameters
TAny unsigned integer type.
Parameters
valAn unsigned integer value.
Returns
val without any modification.

◆ Abs() [6/6]

template<typename T >
requires IsFloatingPoint<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Abs ( T val)
inlineconstexprnoexcept

Computes the absolute value of a floating point value.

Template Parameters
TA floating point type.
Parameters
valA floating point value.
Returns
The absolute value of val.

◆ abs()

template<typename FloatT >
requires IsFloatingPoint<FloatT>
Interval< FloatT > Harlinn::Common::Core::Math::abs ( const Interval< FloatT > & i)
inline

◆ AbsDot() [1/3]

template<Internal::SimdType T, Internal::SimdType U>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::AbsDot ( const T & v1,
const U & v2 )
inlinenoexcept

Calculates the absolute value of the dot product between v1 and v2.

◆ AbsDot() [2/3]

template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd>
requires Internal::IsCompatible<T, U>
ResultT Harlinn::Common::Core::Math::AbsDot ( const T & v1,
const U & v2 )
inlinenoexcept

Calculates the absolute value of the dot product between v1 and v2.

◆ AbsDot() [3/3]

template<Internal::TupleType U, Internal::SimdType T>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::AbsDot ( const U & v1,
const T & v2 )
inlinenoexcept

Calculates the absolute value of the dot product between v1 and v2.

◆ ACos() [1/4]

template<typename FloatT >
requires IsFloatingPoint<FloatT>
Interval< FloatT > Harlinn::Common::Core::Math::ACos ( const Interval< FloatT > & i)
inline

◆ ACos() [2/4]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::ACos ( const T & v)
inlinenoexcept

Calculates the inverse cosine of each element in the argument, in radians.

◆ ACos() [3/4]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::ACos ( const T & v)
inlinenoexcept

Calculates the inverse cosine of each element in the argument, in radians.

◆ ACos() [4/4]

template<typename T >
requires IsFloatingPoint<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::ACos ( T x)
inlineconstexprnoexcept

Computes the principal value of the arc cosine of x.

Template Parameters
TA floating point type.
Parameters
xA floating point value.
Returns
The principal value of the arc cosine of x.

◆ ACosH() [1/2]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::ACosH ( const T & v)
inlinenoexcept

Calculates the inverse hyperbolic cosine of each element in the argument, in radians.

◆ ACosH() [2/2]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::ACosH ( const T & v)
inlinenoexcept

Calculates the inverse hyperbolic cosine of each element in the argument, in radians.

◆ AddAngles() [1/3]

template<Internal::SimdType T, Internal::SimdType U>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::AddAngles ( const T & v1,
const U & v2 )
inlinenoexcept

Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI)

◆ AddAngles() [2/3]

template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd>
requires Internal::IsCompatible<T, U>
ResultT Harlinn::Common::Core::Math::AddAngles ( const T & v1,
const U & v2 )
inlinenoexcept

Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI)

◆ AddAngles() [3/3]

template<Internal::TupleType U, Internal::SimdType T>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::AddAngles ( const U & v1,
const T & v2 )
inlinenoexcept

Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI)

◆ AddRoundDown()

template<typename FloatT >
requires IsFloatingPoint<FloatT>
FloatT Harlinn::Common::Core::Math::AddRoundDown ( FloatT a,
FloatT b )
inlineconstexpr

◆ AddRoundUp()

template<typename FloatT >
requires IsFloatingPoint<FloatT>
FloatT Harlinn::Common::Core::Math::AddRoundUp ( FloatT a,
FloatT b )
inlineconstexpr

◆ AffineTransformationMatrix() [1/2]

template<Internal::SimdType S, Internal::SimdType T, typename U , Internal::SimdType W>
requires (S::Size > 2) && (T::Size > 2) && (W::Size > 2) && IsFloatingPoint<U> && std::is_same_v<typename S::value_type,U> && std::is_same_v<typename T::value_type, U> && std::is_same_v<typename W::value_type, U>
SquareMatrix< U, 4 >::Simd Harlinn::Common::Core::Math::AffineTransformationMatrix ( const S & scaling,
const T & rotationOrigin,
const Quaternion< U > & rotationQuaternion,
const W & translation )
inlinenoexcept

Creates an affine transformation matrix.

Parameters
scalingThe scaling factors for each dimension.
rotationOriginThe center of rotation.
rotationQuaternionRotation factors as a quaternion.
translationThe translation offsets.
Returns

◆ AffineTransformationMatrix() [2/2]

template<Internal::SimdType S, Internal::SimdType T, typename U , Internal::SimdType W>
requires (S::Size > 2) && (T::Size > 2) && (W::Size > 2) && IsFloatingPoint<U> && std::is_same_v<typename S::value_type,U> && std::is_same_v<typename T::value_type, U> && std::is_same_v<typename W::value_type, U>
SquareMatrix< U, 4 >::Simd Harlinn::Common::Core::Math::AffineTransformationMatrix ( const S & scaling,
const T & rotationOrigin,
const QuaternionSimd< Quaternion< U > > & rotationQuaternion,
const W & translation )
inlinenoexcept

Creates an affine transformation matrix.

Parameters
scalingThe scaling factors for each dimension.
rotationOriginThe center of rotation.
rotationQuaternionRotation factors as a quaternion.
translationThe translation offsets.
Returns

◆ AngleBetween() [1/2]

template<VectorSimdType S, VectorSimdType T>
requires Internal::IsCompatible<S, T>
S Harlinn::Common::Core::Math::AngleBetween ( const S & v1,
const T & v2 )
inlinenoexcept

Calculates the angle in radians between two vectors.

Parameters
v1The first vector.
v2The second vector.
Returns
A vector where with each element set to the angle between the two argument vectors.

◆ AngleBetween() [2/2]

template<typename DerivedT , typename FloatT >
Tuple3< DerivedT, FloatT > Harlinn::Common::Core::Math::AngleBetween ( const Tuple3< DerivedT, FloatT > & v1,
const Tuple3< DerivedT, FloatT > & v2 )
inline

◆ AngleBetweenNormals()

template<VectorSimdType S, VectorSimdType T>
requires Internal::IsCompatible<S, T>
S Harlinn::Common::Core::Math::AngleBetweenNormals ( const S & v1,
const T & v2 )
inlinenoexcept

Calculates the angle in radians between two normalized vectors.

Parameters
v1The first normalized vector.
v2

The second normalized vector.

Returns
A vector where with each element set to the angle between the two argument vectors.

◆ ASin() [1/3]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::ASin ( const T & v)
inlinenoexcept

Calculates the inverse sine of each element in the argument, in radians.

◆ ASin() [2/3]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::ASin ( const T & v)
inlinenoexcept

Calculates the inverse sine of each element in the argument, in radians.

◆ ASin() [3/3]

template<typename T >
requires IsFloatingPoint<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::ASin ( T x)
inlineconstexprnoexcept

Computes the principal value of the arc sine of x.

Template Parameters
TA floating point type.
Parameters
xA floating point value.
Returns
The principal value of the arc sine of x.

◆ ASinH() [1/2]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::ASinH ( const T & v)
inlinenoexcept

Calculates the inverse hyperbolic sine of each element in the argument, in radians.

◆ ASinH() [2/2]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::ASinH ( const T & v)
inlinenoexcept

Calculates the inverse hyperbolic sine of each element in the argument, in radians.

◆ ATan() [1/4]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::ATan ( const T & v)
inlinenoexcept

Calculates the inverse tangent of each element in the argument, in radians.

◆ ATan() [2/4]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::ATan ( const T & v)
inlinenoexcept

Calculates the inverse tangent of each element in the argument, in radians.

◆ ATan() [3/4]

template<typename T >
requires IsFloatingPoint<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::ATan ( T x)
inlineconstexprnoexcept

Computes the principal value of the arc tangent of x.

Template Parameters
TA floating point type.
Parameters
xA floating point value.
Returns
The principal value of the arc tangent of x.

◆ ATan() [4/4]

template<typename T >
requires IsFloatingPoint<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::ATan ( T x,
T y )
inlineconstexprnoexcept

Computes the arc tangent of x / y using the signs of arguments to determine the correct quadrant.

Template Parameters
TA floating point type.
Parameters
xA floating point value.
yA floating point value.
Returns
The arc tangent of x / y using the signs of arguments to determine the correct quadrant.

◆ ATan2() [1/4]

template<Internal::SimdType T, Internal::SimdType U>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::ATan2 ( const T & x,
const U & y )
inlinenoexcept

Calculates the inverse tangent of each element in x divided by the corresponding element in y, in radians.

◆ ATan2() [2/4]

template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd>
requires Internal::IsCompatible<T, U>
ResultT Harlinn::Common::Core::Math::ATan2 ( const T & x,
const U & y )
inlinenoexcept

Calculates the inverse tangent of each element in x divided by the corresponding element in y, in radians.

◆ ATan2() [3/4]

template<Internal::TupleType U, Internal::SimdType T>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::ATan2 ( const U & x,
const T & y )
inlinenoexcept

Calculates the inverse tangent of each element in x divided by the corresponding element in y, in radians.

◆ ATan2() [4/4]

template<typename T >
requires IsFloatingPoint<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::ATan2 ( T x,
T y )
inlineconstexprnoexcept

Computes the arc tangent of x / y using the signs of arguments to determine the correct quadrant.

Template Parameters
TA floating point type.
Parameters
xA floating point value.
yA floating point value.
Returns
The arc tangent of x / y using the signs of arguments to determine the correct quadrant.

◆ ATanH() [1/2]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::ATanH ( const T & v)
inlinenoexcept

Calculates the inverse hyperbolic tangent of each element in the argument, in radians.

◆ ATanH() [2/2]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::ATanH ( const T & v)
inlinenoexcept

Calculates the inverse hyperbolic tangent of each element in the argument, in radians.

◆ BaryCentric() [1/5]

template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::SimdType W>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U> && Internal::IsCompatible<S, V>&& Internal::IsCompatible<S, W>
S Harlinn::Common::Core::Math::BaryCentric ( const S & p1,
const T & p2,
const U & p3,
const V & f,
const W & g )
inlinenoexcept

Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.

Parameters
p1The first position.
p2The second position.
p3The third position.
fWeighting factor.
gWeighting factor.

◆ BaryCentric() [2/5]

template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::TupleType W>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& Internal::IsCompatible<S, W>
S Harlinn::Common::Core::Math::BaryCentric ( const S & p1,
const T & p2,
const U & p3,
const V & f,
const W & g )
inlinenoexcept

Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.

Parameters
p1The first position.
p2The second position.
p3The third position.
fWeighting factor.
gWeighting factor.

◆ BaryCentric() [3/5]

template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::SimdType W>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& Internal::IsCompatible<S, W>
S::Simd Harlinn::Common::Core::Math::BaryCentric ( const S & p1,
const T & p2,
const U & p3,
const V & f,
const W & g )
inlinenoexcept

Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.

Parameters
p1The first position.
p2The second position.
p3The third position.
fWeighting factor.
gWeighting factor.

◆ BaryCentric() [4/5]

template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, typename V , typename W >
requires Internal::IsCompatible<S, T> && Internal::IsCompatible<S, U> && IsFloatingPoint<V> && IsFloatingPoint<W>
S::Simd Harlinn::Common::Core::Math::BaryCentric ( const S & p1,
const T & p2,
const U & p3,
const V f,
const W g )
inlinenoexcept

Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.

Parameters
p1The first position.
p2The second position.
p3The third position.
fWeighting factor.
gWeighting factor.

◆ BaryCentric() [5/5]

template<Internal::SimdType S, Internal::SimdType T, Internal::TupleType U, typename V , typename W >
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& IsFloatingPoint<V>&& IsFloatingPoint<W>
S::Simd Harlinn::Common::Core::Math::BaryCentric ( const S & p1,
const T & p2,
const U & p3,
const V f,
const W g )
inlinenoexcept

Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.

Parameters
p1The first position.
p2The second position.
p3The third position.
fWeighting factor.
gWeighting factor.

◆ CatmullRom() [1/4]

template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::SimdType W>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& Internal::IsCompatible<S, W>
S Harlinn::Common::Core::Math::CatmullRom ( const S & p1,
const T & p2,
const U & p3,
const V & p4,
const W & t )
inlinenoexcept

Calculates the Catmull-Rom interpolation, using the specified positions.

Parameters
p1The first position.
p2The second position.
p3The third position.
p4The fourth position.
tThe interpolation control factors.

◆ CatmullRom() [2/4]

template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, Internal::SimdType W>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& Internal::IsCompatible<S, W>
S::Simd Harlinn::Common::Core::Math::CatmullRom ( const S & p1,
const T & p2,
const U & p3,
const V & p4,
const W & t )
inlinenoexcept

Calculates the Catmull-Rom interpolation, using the specified positions.

Parameters
p1The first position.
p2The second position.
p3The third position.
p4The fourth position.
tThe interpolation control factors.

◆ CatmullRom() [3/4]

template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, typename W >
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& IsFloatingPoint<W>
S Harlinn::Common::Core::Math::CatmullRom ( const S & p1,
const T & p2,
const U & p3,
const V & p4,
const W t )
inlinenoexcept

Calculates the Catmull-Rom interpolation, using the specified positions.

Parameters
p1The first position.
p2The second position.
p3The third position.
p4The fourth position.
tThe interpolation control factors.

◆ CatmullRom() [4/4]

template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V, typename W >
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>&& IsFloatingPoint<W>
S::Simd Harlinn::Common::Core::Math::CatmullRom ( const S & p1,
const T & p2,
const U & p3,
const V & p4,
const W t )
inlinenoexcept

Calculates the Catmull-Rom interpolation, using the specified positions.

Parameters
p1The first position.
p2The second position.
p3The third position.
p4The fourth position.
tThe interpolation control factors.

◆ Ceil() [1/7]

template<typename FloatT >
requires IsFloatingPoint<FloatT>
FloatT Harlinn::Common::Core::Math::Ceil ( const Interval< FloatT > & i)
inline

◆ Ceil() [2/7]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::Ceil ( const T & t)
inlinenoexcept

Computes the ceiling of each element held by the argument.

◆ Ceil() [3/7]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::Ceil ( const T & t)
inlinenoexcept

Computes the ceiling of each element held by the argument.

◆ Ceil() [4/7]

template<typename T >
requires IsFloatingPoint<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Ceil ( T value)
inlineconstexprnoexcept

Computes the smallest integer value not less than value.

Template Parameters
TA floating point type.
Parameters
valueA floating point value.
Returns
The smallest integer value not less than value.

◆ Ceil() [5/7]

template<typename T >
requires IsInteger<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Ceil ( T value)
inlineconstexprnoexcept

Just returns value.

Template Parameters
TAn integer type.
Parameters
valueAn integer value.
Returns
value

◆ Ceil() [6/7]

template<typename T >
requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::PointT>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Ceil ( T value)
inlineconstexprnoexcept

◆ Ceil() [7/7]

template<typename T >
requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::SizeT>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Ceil ( T value)
inlineconstexprnoexcept

◆ ceil()

template<typename FloatT >
requires IsFloatingPoint<FloatT>
FloatT Harlinn::Common::Core::Math::ceil ( const Interval< FloatT > & i)
inline

◆ Clamp() [1/9]

template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::Clamp ( const S & v,
const T & lowerBounds,
const U & upperBounds )
inlinenoexcept

Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.

◆ Clamp() [2/9]

template<Internal::SimdType S, Internal::TupleType T, Internal::SimdType U>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U>
U Harlinn::Common::Core::Math::Clamp ( const S & v,
const T & lowerBounds,
const U & upperBounds )
inlinenoexcept

Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.

◆ Clamp() [3/9]

template<Internal::SimdType S, Internal::TupleType T, Internal::TupleType U>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U>
S Harlinn::Common::Core::Math::Clamp ( const S & v,
const T & lowerBounds,
const U & upperBounds )
inlinenoexcept

Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.

◆ Clamp() [4/9]

template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, typename ResultT = typename S::Simd>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<T, U>
ResultT Harlinn::Common::Core::Math::Clamp ( const S & v,
const T & lowerBounds,
const U & upperBounds )
inlinenoexcept

Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.

◆ Clamp() [5/9]

template<typename T >
T & Harlinn::Common::Core::Math::Clamp ( const T & value,
const T & minimumValue,
const T & maximumValue )
inlineconstexpr

◆ Clamp() [6/9]

template<typename T >
requires requires( const T& t1, const T& t2 ) { { t1 < t2 }->std::convertible_to<bool>; }
const T & Harlinn::Common::Core::Math::Clamp ( const T & value,
const T & minimumValue,
const T & maximumValue )
inlineconstexpr

◆ Clamp() [7/9]

template<typename NumberT , Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd>
requires std::is_arithmetic_v<NumberT> && Internal::IsCompatible<T, U>
ResultT Harlinn::Common::Core::Math::Clamp ( NumberT v,
const T & lowerBounds,
const U & upperBounds )
inlinenoexcept

Returns the elements of v, if the elements are between their respective boundaries specified the elements of lowerBounds and the elements of upperBounds, otherwise the value of nearest boundary is returned.

◆ Clamp() [8/9]

template<typename T >
requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::PointT>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Clamp ( T value,
T minimumValue,
T maximumValue )
inlineconstexprnoexcept

◆ Clamp() [9/9]

template<typename T >
requires Harlinn::Windows::Internal::IsSpecializationOf<std::remove_cvref_t<T>, Harlinn::Windows::SizeT>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Clamp ( T value,
T minimumValue,
T maximumValue )
inlineconstexprnoexcept

◆ ClampLength() [1/5]

template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U>
requires Internal::IsCompatible<S, T> && Internal::IsCompatible<S, U>
S Harlinn::Common::Core::Math::ClampLength ( const S & v,
const T & lengthMin,
const U & lengthMax )
inlinenoexcept

Clamps the length of a vector to a given range.

Parameters
vvector to clamp.
lengthMinA vector whose elements are equal to the minimum clamp length. The elements must be greater-than-or-equal to zero.
lengthMaxA vector whose elements are equal to the maximum clamp length. The elements must be greater-than-or-equal to zero.
Returns
Returns a vector whose length is clamped to the specified minimum and maximum.

◆ ClampLength() [2/5]

template<Internal::SimdType S, Internal::SimdType T, Internal::TupleType U>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>
S Harlinn::Common::Core::Math::ClampLength ( const S & v,
const T & lengthMin,
const U & lengthMax )
inlinenoexcept

Clamps the length of a vector to a given range.

Parameters
vvector to clamp.
lengthMinA vector whose elements are equal to the minimum clamp length. The elements must be greater-than-or-equal to zero.
lengthMaxA vector whose elements are equal to the maximum clamp length. The elements must be greater-than-or-equal to zero.
Returns
Returns a vector whose length is clamped to the specified minimum and maximum.

◆ ClampLength() [3/5]

template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>
S::Simd Harlinn::Common::Core::Math::ClampLength ( const S & v,
const T & lengthMin,
const U & lengthMax )
inlinenoexcept

Clamps the length of a vector to a given range.

Parameters
vvector to clamp.
lengthMinA vector whose elements are equal to the minimum clamp length. The elements must be greater-than-or-equal to zero.
lengthMaxA vector whose elements are equal to the maximum clamp length. The elements must be greater-than-or-equal to zero.
Returns
Returns a vector whose length is clamped to the specified minimum and maximum.

◆ ClampLength() [4/5]

template<Internal::SimdType S, typename T , typename U >
requires IsFloatingPoint<T> && IsFloatingPoint<U>
S Harlinn::Common::Core::Math::ClampLength ( const S & v,
const T lengthMin,
const U lengthMax )
inlinenoexcept

Clamps the length of a vector to a given range.

Parameters
vvector to clamp.
lengthMinA vector whose elements are equal to the minimum clamp length. The elements must be greater-than-or-equal to zero.
lengthMaxA vector whose elements are equal to the maximum clamp length. The elements must be greater-than-or-equal to zero.
Returns
Returns a vector whose length is clamped to the specified minimum and maximum.

◆ ClampLength() [5/5]

template<Internal::TupleType S, typename T , typename U >
requires IsFloatingPoint<T>&& IsFloatingPoint<U>
S Harlinn::Common::Core::Math::ClampLength ( const S & v,
const T lengthMin,
const U lengthMax )
inlinenoexcept

Clamps the length of a vector to a given range.

Parameters
vvector to clamp.
lengthMinA vector whose elements are equal to the minimum clamp length. The elements must be greater-than-or-equal to zero.
lengthMaxA vector whose elements are equal to the maximum clamp length. The elements must be greater-than-or-equal to zero.
Returns
Returns a vector whose length is clamped to the specified minimum and maximum.

◆ Conjugate() [1/2]

template<typename T >
requires IsFloatingPoint<T>
QuaternionSimd< Quaternion< T > > Harlinn::Common::Core::Math::Conjugate ( const Quaternion< T > & q1)
noexcept

Calculates the conjugate of a quaternion.

Parameters
q1The quaternion.
Returns
The conjugate of the quaternion

◆ Conjugate() [2/2]

template<typename T >
requires IsFloatingPoint<T>
QuaternionSimd< Quaternion< T > > Harlinn::Common::Core::Math::Conjugate ( const QuaternionSimd< Quaternion< T > > & q1)
noexcept

Calculates the conjugate of a quaternion.

Parameters
q1The quaternion.
Returns
The conjugate of the quaternion

◆ CopySign()

template<typename T >
requires IsFloatingPoint<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::CopySign ( T magnitude,
T signValue )
inlineconstexprnoexcept

Composes a floating point value with the magnitude of magnitude and the sign of signValue.

Template Parameters
TA floating point type.
Parameters
magnitudeA floating point value.
signValueA floating point value.
Returns
A floating point value with the magnitude of magnitude and the sign of signValue.

◆ Cos() [1/4]

template<typename FloatT >
requires IsFloatingPoint<FloatT>
Interval< FloatT > Harlinn::Common::Core::Math::Cos ( const Interval< FloatT > & i)
inline

◆ Cos() [2/4]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::Cos ( const T & v)
inlinenoexcept

Calculates the cosine of each element in the argument expressed in radians.

◆ Cos() [3/4]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::Cos ( const T & v)
inlinenoexcept

Calculates the cosine of each element in the argument expressed in radians.

◆ Cos() [4/4]

template<typename T >
requires IsFloatingPoint<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Cos ( T x)
inlineconstexprnoexcept

Computes the cosine of x given in radians.

Template Parameters
TA floating point type.
Parameters
xA floating point value.
Returns
The cosine of x given in radians.

◆ CosH() [1/2]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::CosH ( const T & v)
inlinenoexcept

Calculates the hyperbolic cosine of each element in the argument expressed in radians.

◆ CosH() [2/2]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::CosH ( const T & v)
inlinenoexcept

Calculates the hyperbolic cosine of each element in the argument expressed in radians.

◆ Cross() [1/3]

template<Internal::SimdType T, Internal::SimdType U>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::Cross ( const T & v1,
const U & v2 )
inlinenoexcept

Calculates the cross product between v1 and v2.

◆ Cross() [2/3]

template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd>
requires Internal::IsCompatible<T, U>
ResultT Harlinn::Common::Core::Math::Cross ( const T & v1,
const U & v2 )
inlinenoexcept

Calculates the cross product between v1 and v2.

◆ Cross() [3/3]

template<Internal::TupleType U, Internal::SimdType T>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::Cross ( const U & v1,
const T & v2 )
inlinenoexcept

Calculates the cross product between v1 and v2.

◆ Deg2Rad()

template<typename T >
requires IsFloatingPoint<std::remove_cvref_t<T>>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Deg2Rad ( T angleInDegrees)
inlineconstexprnoexcept

Converts an angle in degrees into the corresponding angle in radians.

Template Parameters
TA floating point type.
Parameters
angleInDegreesThe angle in degrees.
Returns
The angle in radians.

◆ Degrees()

template<typename FloatT >
requires IsFloatingPoint<FloatT>
FloatT Harlinn::Common::Core::Math::Degrees ( FloatT rad)
inlineconstexpr

◆ Determinant() [1/6]

Vector< float, 2 >::Simd Harlinn::Common::Core::Math::Determinant ( const SquareMatrix< float, 2 > & matrix)
inline

◆ Determinant() [2/6]

Vector< float, 4 >::Simd Harlinn::Common::Core::Math::Determinant ( const SquareMatrix< float, 4ULL > & matrix)
inline

Calculates the determinant of a matrix.

Parameters
matrixThe matrix that the determinant will be calculated for.
Returns
Returns a Vector<float,4>::Simd with all the elements set to the determinant of the matrix.

◆ Determinant() [3/6]

Vector< float, 2 >::Simd Harlinn::Common::Core::Math::Determinant ( const typename SquareMatrix< float, 2 >::Simd & matrix)
inline

◆ Determinant() [4/6]

Vector< float, 3 >::Simd Harlinn::Common::Core::Math::Determinant ( const typename SquareMatrix< float, 3 > & matrix)
inline

◆ Determinant() [5/6]

Vector< float, 3 >::Simd Harlinn::Common::Core::Math::Determinant ( const typename SquareMatrix< float, 3 >::Simd & matrix)
inline

◆ Determinant() [6/6]

Vector< float, 4 >::Simd Harlinn::Common::Core::Math::Determinant ( const typename SquareMatrix< float, 4 >::Simd & matrix)
inline

Calculates the determinant of a matrix.

Parameters
matrixThe matrix that the determinant will be calculated for.
Returns
Returns a Vector<float,4>::Simd with all the elements set to the determinant of the matrix.

◆ DifferenceOfProducts() [1/8]

template<typename FloatT >
requires IsFloatingPoint<FloatT>
Interval< FloatT > Harlinn::Common::Core::Math::DifferenceOfProducts ( const Interval< FloatT > & a,
const Interval< FloatT > & b,
const Interval< FloatT > & c,
const Interval< FloatT > & d )
inline

◆ DifferenceOfProducts() [2/8]

template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::SimdType V>
requires Internal::IsCompatible<S, T> && Internal::IsCompatible<S, U> && Internal::IsCompatible<S, V>
T Harlinn::Common::Core::Math::DifferenceOfProducts ( const S & v1,
const T & v2,
const U & v3,
const V & v4 )
inlinenoexcept

Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.

◆ DifferenceOfProducts() [3/8]

template<Internal::SimdType S, Internal::SimdType T, Internal::SimdType U, Internal::TupleType V>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>
S Harlinn::Common::Core::Math::DifferenceOfProducts ( const S & v1,
const T & v2,
const U & v3,
const V & v4 )
inlinenoexcept

Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.

◆ DifferenceOfProducts() [4/8]

template<Internal::TupleType S, Internal::SimdType T, Internal::SimdType U, Internal::TupleType V>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>
T Harlinn::Common::Core::Math::DifferenceOfProducts ( const S & v1,
const T & v2,
const U & v3,
const V & v4 )
inlinenoexcept

Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.

◆ DifferenceOfProducts() [5/8]

template<Internal::TupleType S, Internal::TupleType T, Internal::SimdType U, Internal::SimdType V>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>
U Harlinn::Common::Core::Math::DifferenceOfProducts ( const S & v1,
const T & v2,
const U & v3,
const V & v4 )
inlinenoexcept

Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.

◆ DifferenceOfProducts() [6/8]

template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, Internal::SimdType V>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>
V Harlinn::Common::Core::Math::DifferenceOfProducts ( const S & v1,
const T & v2,
const U & v3,
const V & v4 )
inlinenoexcept

Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.

◆ DifferenceOfProducts() [7/8]

template<Internal::TupleType S, Internal::TupleType T, Internal::TupleType U, Internal::TupleType V>
requires Internal::IsCompatible<S, T>&& Internal::IsCompatible<S, U>&& Internal::IsCompatible<S, V>
S::Simd Harlinn::Common::Core::Math::DifferenceOfProducts ( const S & v1,
const T & v2,
const U & v3,
const V & v4 )
inlinenoexcept

Calculates the difference between the product of the first and the second argument, and the product of the third and fourth argument.

◆ DifferenceOfProducts() [8/8]

template<typename Ta , typename Tb , typename Tc , typename Td >
requires IsFloatingPoint<Ta> && IsFloatingPoint<Tb> && IsFloatingPoint<Tc> && IsFloatingPoint<Td>
auto Harlinn::Common::Core::Math::DifferenceOfProducts ( Ta a,
Tb b,
Tc c,
Td d )
inlineconstexpr

◆ Distance() [1/3]

template<Internal::SimdType T, Internal::SimdType U>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::Distance ( const T & p1,
const U & p2 )
inlinenoexcept

Calculates the distance between p1 and p2.

◆ Distance() [2/3]

template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd>
requires Internal::IsCompatible<T, U>
ResultT Harlinn::Common::Core::Math::Distance ( const T & p1,
const U & p2 )
inlinenoexcept

Calculates the distance between p1 and p2.

◆ Distance() [3/3]

template<Internal::TupleType U, Internal::SimdType T>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::Distance ( const U & p1,
const T & p2 )
inlinenoexcept

Calculates the distance between p1 and p2.

◆ DistanceSquared() [1/3]

template<Internal::SimdType T, Internal::SimdType U>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::DistanceSquared ( const T & p1,
const U & p2 )
inlinenoexcept

Calculates the squared distance between p1 and p2.

◆ DistanceSquared() [2/3]

template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd>
requires Internal::IsCompatible<T, U>
ResultT Harlinn::Common::Core::Math::DistanceSquared ( const T & p1,
const U & p2 )
inlinenoexcept

Calculates the squared distance between p1 and p2.

◆ DistanceSquared() [3/3]

template<Internal::TupleType U, Internal::SimdType T>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::DistanceSquared ( const U & p1,
const T & p2 )
inlinenoexcept

Calculates the squared distance between p1 and p2.

◆ DivRoundDown()

template<typename FloatT >
requires IsFloatingPoint<FloatT>
FloatT Harlinn::Common::Core::Math::DivRoundDown ( FloatT a,
FloatT b )
inlineconstexpr

◆ DivRoundUp()

template<typename FloatT >
requires IsFloatingPoint<FloatT>
FloatT Harlinn::Common::Core::Math::DivRoundUp ( FloatT a,
FloatT b )
inlineconstexpr

◆ Dot() [1/7]

template<typename T >
requires IsFloatingPoint<T>
Vector< T, 4 >::Simd Harlinn::Common::Core::Math::Dot ( const Quaternion< T > & q1,
const Quaternion< T > & q2 )
noexcept

Calculates the dot product of two quaternions.

Parameters
q1The first quaternion.
q2The second quaternion.
Returns
The dot product between q1 and q2.

◆ Dot() [2/7]

template<typename T >
requires IsFloatingPoint<T>
Vector< T, 4 >::Simd Harlinn::Common::Core::Math::Dot ( const Quaternion< T > & q1,
const QuaternionSimd< Quaternion< T > > & q2 )
noexcept

Calculates the dot product of two quaternions.

Parameters
q1The first quaternion.
q2The second quaternion.
Returns
The dot product between q1 and q2.

◆ Dot() [3/7]

template<typename T >
requires IsFloatingPoint<T>
Vector< T, 4 >::Simd Harlinn::Common::Core::Math::Dot ( const QuaternionSimd< Quaternion< T > > & q1,
const Quaternion< T > & q2 )
noexcept

Calculates the dot product of two quaternions.

Parameters
q1The first quaternion.
q2The second quaternion.
Returns
The dot product between q1 and q2.

◆ Dot() [4/7]

template<typename T >
requires IsFloatingPoint<T>
Vector< T, 4 >::Simd Harlinn::Common::Core::Math::Dot ( const QuaternionSimd< Quaternion< T > > & q1,
const QuaternionSimd< Quaternion< T > > & q2 )
noexcept

Calculates the dot product of two quaternions.

Parameters
q1The first quaternion.
q2The second quaternion.
Returns
The dot product between q1 and q2.

◆ Dot() [5/7]

template<Internal::SimdType T, Internal::SimdType U>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::Dot ( const T & v1,
const U & v2 )
inlinenoexcept

Calculates the dot product between v1 and v2.

◆ Dot() [6/7]

template<Internal::TupleType T, Internal::TupleType U, typename ResultT = typename T::Simd>
requires Internal::IsCompatible<T, U>
ResultT Harlinn::Common::Core::Math::Dot ( const T & v1,
const U & v2 )
inlinenoexcept

Calculates the dot product between v1 and v2.

◆ Dot() [7/7]

template<Internal::TupleType U, Internal::SimdType T>
requires Internal::IsCompatible<T, U>
T Harlinn::Common::Core::Math::Dot ( const U & v1,
const T & v2 )
inlinenoexcept

Calculates the dot product between v1 and v2.

◆ ErfInv()

template<typename FloatT >
requires IsFloatingPoint<FloatT>
FloatT Harlinn::Common::Core::Math::ErfInv ( FloatT a)
inlineconstexpr

◆ EvaluatePolynomial() [1/2]

template<typename FloatT , typename C >
FloatT Harlinn::Common::Core::Math::EvaluatePolynomial ( FloatT t,
C c )
inlineconstexpr

◆ EvaluatePolynomial() [2/2]

template<typename FloatT , typename C , typename... Args>
FloatT Harlinn::Common::Core::Math::EvaluatePolynomial ( FloatT t,
C c,
Args... remaining )
inlineconstexpr

◆ Exp() [1/3]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::Exp ( const T & v)
inlinenoexcept

Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument.

◆ Exp() [2/3]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::Exp ( const T & v)
inlinenoexcept

Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument.

◆ Exp() [3/3]

template<typename T >
requires IsFloatingPoint<T>
std::remove_cvref_t< T > Harlinn::Common::Core::Math::Exp ( T x)
inlineconstexprnoexcept

Computes e, 2.7182818, raised to the given power x.

Template Parameters
TA floating point type.
Parameters
xA floating point value.
Returns
e raised to the given power x.

◆ Exp10() [1/2]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::Exp10 ( const T & v)
inlinenoexcept

Calculates the base-10 exponential of each element in the argument.

◆ Exp10() [2/2]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::Exp10 ( const T & v)
inlinenoexcept

Calculates the base-10 exponential of each element in the argument.

◆ Exp2() [1/2]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::Exp2 ( const T & v)
inlinenoexcept

Calculates the base-2 exponential of each element in the argument.

◆ Exp2() [2/2]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::Exp2 ( const T & v)
inlinenoexcept

Calculates the base-2 exponential of each element in the argument.

◆ ExpM1() [1/3]

template<Internal::SimdType T>
T Harlinn::Common::Core::Math::ExpM1 ( const T & v)
inlinenoexcept

Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument, $$-1.0$$.

◆ ExpM1() [2/3]

template<Internal::TupleType T, typename ResultT = typename T::Simd>
ResultT Harlinn::Common::Core::Math::ExpM1 ( const T & v)
inlinenoexcept

Calculates $$e$$ (Euler's number, 2.7182818...), raised to the power of each element in the argument, $$-1.0$$.

◆ ExpM1() [3/3]

template<typename FloatT >
requires IsFloatingPoint<FloatT>
FloatT Harlinn::Common::Core::Math::ExpM1 ( FloatT x)
constexpr

◆ FastExp()

float Harlinn::Common::Core::Math::FastExp ( float x)
inlineconstexpr

◆ FastLog2()

template<typename FloatT >
requires IsFloatingPoint<FloatT>
FloatT Harlinn::Common::Core::Math::FastLog2 ( FloatT x)
inlineconstexpr