misc/gen/math.h

Go to the documentation of this file.

#pragma once
#include <array>
#include <cmath>
#include <misc/global.h>
#include <random>
 
namespace sf
{
 
namespace numbers
{
 
#if __cplusplus <= 201703L
 
template<typename T>
inline constexpr T pi_v = static_cast<T>(3.141592653589793238462643383279502884L);
 
#else
 
template<typename T>
inline constexpr T pi_v = ::std::numbers::pi_v<T>;
 
#endif
}// namespace numbers
 
template<typename T>
T round(T value, T rnd)
{
  // Prevent non-integer and non-float types from implementing this template.
  static_assert(std::is_arithmetic_v<T>, "Type T must be an arithmetic type.");
  if constexpr (std::is_integral_v<T>)
  {
    return (value + rnd / T(2)) / rnd * rnd;
  }
  if constexpr (std::is_floating_point_v<T>)
  {
    // Function 'std::floor' has al float types implemented.
    return std::floor(value / rnd + T(0.5)) * rnd;
  }
  return value;
}
 
template<typename T, typename S>
S calculateOffset(T value, T min, T max, S len, bool clip)
{
  max -= min;
  value -= min;
  S temp = max && value ? (std::is_floating_point_v<T> ? len * (value / max) : len * value / max) : 0;
  // Clip when required.
  if (clip)
  {
    // When the len is a negative value.
    if (len < 0)
    {
      return temp < len ? len : temp > S(0) ? S(0) : temp;
    }
    return temp > len ? len : temp < S(0) ? S(0) : temp;
  }
  return temp;
}
 
template<typename T>
T clip(const T value, const T lower_lim, const T upper_lim)
{
  return value < lower_lim ? lower_lim : value > upper_lim ? upper_lim : value;
}
 
template<typename T>
T random(T start, T stop)
{
  static std::default_random_engine generator{};// NOLINT(cert-msc32-c,cert-msc51-cpp)
  std::uniform_int_distribution<T> distribution(start, stop);
  return distribution(generator);
}
 
template<typename T>
T modulo(T k, T n)
{
  // Only implementations of arithmetic values are allowed.
  static_assert(std::is_arithmetic_v<T>, "Type T must be an arithmetic type.");
  // Distinguish between floats and integers.
  if constexpr (std::is_floating_point_v<T>)
  {
    // Function fmod has implementations for any floating point.
    T r = std::fmod(k, n);
    //if the r is less than zero, add n to put it in the [0, n-1] range if n is positive
    //if the r is greater than zero, add n to put it in the [n-1, 0] range if n is negative
    return (n > 0 && r < 0) || (n < 0 && r > 0) ? r + n : r;
  }
  else
  {
    T r = k % n;
    //if the r is less than zero, add n to put it in the [0, n-1] range if n is positive
    //if the r is greater than zero, add n to put it in the [n-1, 0] range if n is negative
    return (n > 0 && r < 0) || (n < 0 && r > 0) ? r + n : r;
  }
}
 
template<typename T>
T toAbs(T v)
{
  static_assert(std::is_arithmetic_v<T>, "Type T must be an arithmetic type.");
  if constexpr (std::is_same<T, long double>())
  {
    return fabsl(v);
  }
  if constexpr (std::is_same<T, double>())
  {
    return fabs(v);
  }
  if constexpr (std::is_same<T, float>())
  {
    return fabsf(v);
  }
  if constexpr (std::is_integral_v<T>)
  {
    if constexpr (std::numeric_limits<T>::is_signed)
    {
      if constexpr (std::is_same<T, long long int>())
      {
        return std::llabs(v);
      }
      if constexpr (std::is_same<T, long int>())
      {
        return std::labs(v);
      }
      if constexpr (std::is_same<T, int>())
      {
        return std::abs(v);
      }
      // Smaller integers are handled here.
      return static_cast<T>(std::abs(v));
    }
  }
  // Not a signed value return it as is.
  return v;
}
 
template<typename T>
T ipow(T base, int exponent)
{
  // Prevent non-integer types from implementing this template.
  static_assert(std::is_integral_v<T>, "Type T must be an integer type.");
  // Initialize the integer.
  T rv{1};
  for (;;)
  {
    // Check if the first bit is set.
    if (exponent & 1)
    {
      rv *= base;
    }
    // Shift the bits right.
    exponent >>= 1;
    // When no bits are standing of the exponent done break th loop.
    if (!exponent)
    {
      break;
    }
    // Squaring the values so far.
    base *= base;
  }
  return rv;
}
 
template<typename T>
constexpr T toRadians(T degrees)
{
  // Only implemented for floating point values.
  static_assert(std::is_floating_point_v<T>, "Type T must be a floating point type.");
  return degrees * (numbers::pi_v<T> / 180);
}
 
template<typename T>
constexpr T toDegrees(T radians)
{
  // Only implemented for floating point values.
  static_assert(std::is_floating_point_v<T>, "Type T must be a floating point type.");
  return radians / numbers::pi_v<T> * 180;
}
 
template<typename T>
bool isEqual(T a, T b, T epsilon = std::numeric_limits<T>::epsilon())
{
  // Only implemented for floating point values.
  static_assert(std::is_floating_point_v<T>, "Type T must be a floating point type.");
  return std::abs(a - b) <= epsilon;
}
 
template<typename T>
bool isZero(T value, T epsilon = std::numeric_limits<T>::epsilon())
{
  static_assert(std::is_arithmetic_v<T>, "Type T must be an arithmetic type.");
  if constexpr (std::is_integral_v<T>)
  {
    return value == std::numeric_limits<T>::denorm_min();
  }
  if constexpr (std::is_floating_point_v<T>)
  {
    return std::fabs(value) < epsilon;
  }
  return false;
}
 
template<typename T>
bool isValidValue(T value)
{
  static_assert(std::is_floating_point_v<T>, "Type T must be an floating point type.");
  return !std::isinf(value) && !std::isnan(value);
}
 
template<typename T, typename... Args>
size_t maxArgumentIndex(T first, Args... args)
{
  T largest = first;
  size_t idx = 0;
  size_t idx_cur = 0;
  // Lambda to find the largest value and its index
  auto compare = [&largest, &idx, &idx_cur](T value) {
    if (value > largest)
    {
      largest = value;
      idx = idx_cur;
    }
    ++idx_cur;
  };
  (compare(first), ..., compare(args));// Apply to all arguments
  return idx;
}
 
template<typename T, typename... Args>
size_t minArgumentIndex(T first, Args... args)
{
  T largest = first;
  size_t idx = 0;
  size_t idx_cur = 0;
  // Lambda to find the largest value and its index
  auto compare = [&largest, &idx, &idx_cur](T value) {
    if (value < largest)
    {
      largest = value;
      idx = idx_cur;
    }
    ++idx_cur;
  };
  (compare(first), ..., compare(args));// Apply to all arguments
  return idx;
}
 
template<typename T, size_t N>
size_t maxArrayIndex(const std::array<T, N>& arr)
{
  T cur = arr[0];
  size_t index = 0;
  for (size_t i = 1; i < arr.size(); ++i)
  {
    if (arr[i] > cur)
    {
      cur = arr[i];
      index = i;
    }
  }
  return index;
}
 
template<typename T, size_t N>
size_t minArrayIndex(const std::array<T, N>& arr)
{
  T cur = arr[0];
  size_t index = 0;
  for (size_t i = 1; i < arr.size(); ++i)
  {
    if (arr[i] < cur)
    {
      cur = arr[i];
      index = i;
    }
  }
  return index;
}
 
_MISC_FUNC int precision(double value);
 
_MISC_FUNC int digits(double value);
 
template<typename T>
std::pair<T, int> getMantissaExponent(T value)
{
  // Allow only floating point values.
  static_assert(std::is_floating_point_v<T>, "Type T must be a floating point type.");
  // Return zero for value zero.
  if (isZero(value))
    return {0, 0};
  auto exponent = std::floor(std::log10(std::abs(value)));
  auto mantissa = value / std::pow(10, exponent);
  // Adjust mantissa and exponent to ensure |mantissa| is between 0.1 and 1.0
  if (std::abs(mantissa) < 0.1)
  {
    mantissa *= 10;
    exponent -= 1;
  }
  else if (abs(mantissa) >= 1.0)
  {
    mantissa /= 10;
    exponent += 1;
  }
  return {mantissa, exponent};
}
 
template<typename T>
int magnitude(T value)
{
  return getMantissaExponent(value).second;
}
 
_MISC_FUNC int magnitudeObsolete(double value);
 
_MISC_FUNC int requiredDigits(double round_val, double min_val, double max_val);
 
}// namespace sf