Math.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Math/Angle.h>
#include <Foundation/Math/Constants.h>
#include <Foundation/Math/Declarations.h>
 
 
namespace plMath
{
  template <typename Type>
  constexpr static bool IsNaN(Type value)
  {
    return false;
  }
 
  template <typename Type>
  constexpr static bool IsFinite(Type value)
  {
    return true;
  }
 
 
  [[nodiscard]] float Sin(plAngle a); // [tested]
 
  [[nodiscard]] float Cos(plAngle a); // [tested]
 
  [[nodiscard]] float Tan(plAngle a); // [tested]
 
  [[nodiscard]] plAngle ASin(float f); // [tested]
 
  [[nodiscard]] plAngle ACos(float f); // [tested]
 
  [[nodiscard]] plAngle ATan(float f); // [tested]
 
  [[nodiscard]] plAngle ATan2(float y, float x); // [tested]
 
  [[nodiscard]] float Exp(float f); // [tested]
 
  [[nodiscard]] float Ln(float f); // [tested]
 
  [[nodiscard]] float Log2(float f); // [tested]
 
  [[nodiscard]] plUInt32 Log2i(plUInt32 uiVal); // [tested]
 
  [[nodiscard]] float Log10(float f); // [tested]
 
  [[nodiscard]] float Log(float fBase, float f); // [tested]
 
  [[nodiscard]] float Pow2(float f); // [tested]
 
  [[nodiscard]] float Pow(float fBase, float fExp); // [tested]
 
  [[nodiscard]] constexpr plInt32 Pow2(plInt32 i); // [tested]
 
  [[nodiscard]] plInt32 Pow(plInt32 iBase, plInt32 iExp); // [tested]
 
  template <typename T>
  [[nodiscard]] constexpr T Square(T f); // [tested]
 
  [[nodiscard]] float Sqrt(float f); // [tested]
 
  [[nodiscard]] double Sqrt(double f); // [tested]
 
  [[nodiscard]] float Root(float f, float fNthRoot); // [tested]
 
  template <typename T>
  [[nodiscard]] constexpr T Sign(T f); // [tested]
 
  template <typename T>
  [[nodiscard]] constexpr T Abs(T f); // [tested]
 
  template <typename T>
  [[nodiscard]] constexpr T Min(T f1, T f2); // [tested]
 
  template <typename T, typename... ARGS>
  [[nodiscard]] constexpr T Min(T f1, T f2, ARGS... f); // [tested]
 
  template <typename T>
  [[nodiscard]] constexpr T Max(T f1, T f2); // [tested]
 
  template <typename T, typename... ARGS>
  [[nodiscard]] constexpr T Min(T f1, T f2, ARGS... f); // [tested]
 
  template <typename T>
  [[nodiscard]] constexpr T Clamp(T value, T min_val, T max_val); // [tested]
 
  template <typename T>
  [[nodiscard]] constexpr T Saturate(T value); // [tested]
 
  [[nodiscard]] float Floor(float f); // [tested]
 
  [[nodiscard]] float Ceil(float f); // [tested]
 
  [[nodiscard]] float RoundDown(float f, float fMultiple); // [tested]
 
  [[nodiscard]] double RoundDown(double f, double fMultiple); // [tested]
 
  [[nodiscard]] float RoundUp(float f, float fMultiple); // [tested]
 
  [[nodiscard]] double RoundUp(double f, double fMultiple); // [tested]
 
  template <typename Type>
  [[nodiscard]] Type Trunc(Type f); // [tested]
 
  [[nodiscard]] constexpr plInt32 FloatToInt(float value);
 
  // There is a compiler bug in VS 2019 targeting 32-bit that causes an internal compiler error when casting double to long long.
  // FloatToInt(double) is not available on these version of the MSVC compiler.
#if PL_DISABLED(PL_PLATFORM_ARCH_X86) || (_MSC_VER <= 1916)
  [[nodiscard]] constexpr plInt64 FloatToInt(double value);
#endif
 
  [[nodiscard]] float Round(float f); // [tested]
 
  [[nodiscard]] double Round(double f); // [tested]
 
  [[nodiscard]] float RoundToMultiple(float f, float fMultiple);
 
  [[nodiscard]] double RoundToMultiple(double f, double fMultiple);
 
  template <typename Type>
  [[nodiscard]] Type Fraction(Type f); // [tested]
 
  [[nodiscard]] float Mod(float value, float fDiv); // [tested]
 
  [[nodiscard]] double Mod(double f, double fDiv); // [tested]
 
  template <typename Type>
  [[nodiscard]] constexpr Type Invert(Type f); // [tested]
 
  [[nodiscard]] constexpr plInt32 RoundUp(plInt32 value, plUInt16 uiMultiple); // [tested]
 
  [[nodiscard]] constexpr plInt32 RoundDown(plInt32 value, plUInt16 uiMultiple); // [tested]
 
  [[nodiscard]] constexpr plUInt32 RoundUp(plUInt32 value, plUInt16 uiMultiple); // [tested]
 
  [[nodiscard]] constexpr plUInt32 RoundDown(plUInt32 value, plUInt16 uiMultiple); // [tested]
 
  [[nodiscard]] constexpr bool IsOdd(plInt32 i); // [tested]
 
  [[nodiscard]] constexpr bool IsEven(plInt32 i); // [tested]
 
  [[nodiscard]] plUInt32 FirstBitLow(plUInt32 uiBitmask); // [tested]
 
  [[nodiscard]] plUInt32 FirstBitLow(plUInt64 uiBitmask); // [tested]
 
  [[nodiscard]] plUInt32 FirstBitHigh(plUInt32 uiBitmask); // [tested]
 
  [[nodiscard]] plUInt32 FirstBitHigh(plUInt64 uiBitmask); // [tested]
 
  [[nodiscard]] plUInt32 CountTrailingZeros(plUInt32 uiBitmask); // [tested]
 
  [[nodiscard]] plUInt32 CountTrailingZeros(plUInt64 uiBitmask); // [tested]
 
  [[nodiscard]] plUInt32 CountLeadingZeros(plUInt32 uiBitmask); // [tested]
 
  [[nodiscard]] plUInt32 CountBits(plUInt32 value);
 
  [[nodiscard]] plUInt32 CountBits(plUInt64 value);
 
  template <typename Type>
  [[nodiscard]] Type Bitmask_LowN(plUInt32 uiNumBitsToSet);
 
  template <typename Type>
  [[nodiscard]] Type Bitmask_HighN(plUInt32 uiNumBitsToSet);
 
  template <typename T>
  void Swap(T& ref_f1, T& ref_f2); // [tested]
 
  template <typename T>
  [[nodiscard]] T Lerp(T f1, T f2, float fFactor); // [tested]
 
  template <typename T>
  [[nodiscard]] T Lerp(T f1, T f2, double fFactor); // [tested]
 
  template <typename T>
  [[nodiscard]] constexpr float Unlerp(T fMin, T fMax, T fValue); // [tested]
 
  template <typename T>
  [[nodiscard]] constexpr T Step(T value, T edge); // [tested]
 
  template <typename Type>
  [[nodiscard]] Type SmoothStep(Type value, Type edge1, Type edge2); // [tested]
 
  template <typename Type>
  [[nodiscard]] Type SmootherStep(Type value, Type edge1, Type edge2); // [tested]
 
  [[nodiscard]] PL_FOUNDATION_DLL bool IsPowerOf(plInt32 value, plInt32 iBase); // [tested]
 
  [[nodiscard]] constexpr bool IsPowerOf2(plInt32 value); // [tested]
 
  [[nodiscard]] constexpr bool IsPowerOf2(plUInt32 value); // [tested]
 
  [[nodiscard]] constexpr bool IsPowerOf2(plUInt64 value); // [tested]
 
  [[nodiscard]] PL_FOUNDATION_DLL plUInt32 PowerOfTwo_Floor(plUInt32 value); // [tested]
 
  [[nodiscard]] PL_FOUNDATION_DLL plUInt64 PowerOfTwo_Floor(plUInt64 value); // [tested]
 
  [[nodiscard]] PL_FOUNDATION_DLL plUInt32 PowerOfTwo_Ceil(plUInt32 value); // [tested]
 
  [[nodiscard]] PL_FOUNDATION_DLL plUInt64 PowerOfTwo_Ceil(plUInt64 value); // [tested]
 
  [[nodiscard]] PL_FOUNDATION_DLL plUInt32 GreatestCommonDivisor(plUInt32 a, plUInt32 b); // [tested]
 
  template <typename Type>
  [[nodiscard]] constexpr bool IsEqual(Type lhs, Type rhs, Type fEpsilon);
 
  template <typename T>
  [[nodiscard]] constexpr bool IsInRange(T value, T minVal, T maxVal); // [tested]
 
  template <typename Type>
  [[nodiscard]] bool IsZero(Type f, Type fEpsilon); // [tested]
 
  [[nodiscard]] plUInt8 ColorFloatToByte(float value); // [tested]
 
  [[nodiscard]] plUInt16 ColorFloatToShort(float value); // [tested]
 
  [[nodiscard]] plInt8 ColorFloatToSignedByte(float value); // [tested]
 
  [[nodiscard]] plInt16 ColorFloatToSignedShort(float value); // [tested]
 
  [[nodiscard]] constexpr float ColorByteToFloat(plUInt8 value); // [tested]
 
  [[nodiscard]] constexpr float ColorShortToFloat(plUInt16 value); // [tested]
 
  [[nodiscard]] constexpr float ColorSignedByteToFloat(plInt8 value); // [tested]
 
  [[nodiscard]] constexpr float ColorSignedShortToFloat(plInt16 value); // [tested]
 
  template <typename T, typename T2>
  [[nodiscard]] T EvaluateBezierCurve(T2 t, const T& startPoint, const T& controlPoint1, const T& controlPoint2, const T& endPoint);
 
  PL_FOUNDATION_DLL plResult TryMultiply32(plUInt32& out_uiResult, plUInt32 a, plUInt32 b, plUInt32 c = 1, plUInt32 d = 1); // [tested]
 
  [[nodiscard]] PL_FOUNDATION_DLL plUInt32 SafeMultiply32(plUInt32 a, plUInt32 b, plUInt32 c = 1, plUInt32 d = 1);
 
  PL_FOUNDATION_DLL plResult TryMultiply64(plUInt64& out_uiResult, plUInt64 a, plUInt64 b, plUInt64 c = 1, plUInt64 d = 1); // [tested]
 
  [[nodiscard]] PL_FOUNDATION_DLL plUInt64 SafeMultiply64(plUInt64 a, plUInt64 b, plUInt64 c = 1, plUInt64 d = 1);
 
  plResult TryConvertToSizeT(size_t& out_uiResult, plUInt64 uiValue); // [tested]
 
  [[nodiscard]] PL_FOUNDATION_DLL size_t SafeConvertToSizeT(plUInt64 uiValue);
 
  [[nodiscard]] PL_FOUNDATION_DLL float ReplaceNaN(float fValue, float fFallback); // [tested]
 
  [[nodiscard]] PL_FOUNDATION_DLL double ReplaceNaN(double fValue, double fFallback); // [tested]
 
} // namespace plMath
 
#include <Foundation/Math/Implementation/MathDouble_inl.h>
#include <Foundation/Math/Implementation/MathFixedPoint_inl.h>
#include <Foundation/Math/Implementation/MathFloat_inl.h>
#include <Foundation/Math/Implementation/MathInt32_inl.h>
#include <Foundation/Math/Implementation/Math_inl.h>