math_func.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef MATH_FUNC_HPP
#define MATH_FUNC_HPP
 
#include "convertible_through_base.hpp"

template <typename T>
constexpr T abs(const T a)
{
  return (a < static_cast<T>(0)) ? -a : a;
}

template <typename T>
constexpr T Align(const T x, uint n)
{
  assert((n & (n - 1)) == 0 && n != 0);
  n--;
  return static_cast<T>((x + n) & ~static_cast<T>(n));
}

template <typename T>
constexpr T *AlignPtr(T *x, uint n)
{
  static_assert(sizeof(uintptr_t) == sizeof(void *));
  return reinterpret_cast<T *>(Align(reinterpret_cast<uintptr_t>(x), n));
}

template <typename T>
constexpr T Clamp(const T a, const T min, const T max)
{
  assert(min <= max);
  if (a <= min) return min;
  if (a >= max) return max;
  return a;
}

template <typename T>
constexpr T SoftClamp(const T a, const T min, const T max)
{
  if (min > max) {
    using U = std::make_unsigned_t<T>;
    return min - (U(min) - max) / 2;
  }
  if (a <= min) return min;
  if (a >= max) return max;
  return a;
}

constexpr int Clamp(const int a, const int min, const int max)
{
  return Clamp<int>(a, min, max);
}

constexpr uint ClampU(const uint a, const uint min, const uint max)
{
  return Clamp<uint>(a, min, max);
}

template <typename To, typename From, std::enable_if_t<std::is_integral<From>::value, int> = 0>
constexpr To ClampTo(From value)
{
  static_assert(std::numeric_limits<To>::is_integer, "Do not clamp from non-integer values");
  static_assert(std::numeric_limits<From>::is_integer, "Do not clamp to non-integer values");
 
  if constexpr (sizeof(To) >= sizeof(From) && std::numeric_limits<To>::is_signed == std::numeric_limits<From>::is_signed) {
    /* Same signedness and To type is larger or equal than From type, no clamping is required. */
    return static_cast<To>(value);
  }
 
  if constexpr (sizeof(To) > sizeof(From) && std::numeric_limits<To>::is_signed) {
    /* Signed destination and a larger To type, no clamping is required. */
    return static_cast<To>(value);
  }
 
  /* Get the bigger of the two types based on essentially the number of bits. */
  using BiggerType = typename std::conditional<sizeof(From) >= sizeof(To), From, To>::type;
 
  if constexpr (std::numeric_limits<To>::is_signed) {
    /* The output is a signed number. */
    if constexpr (std::numeric_limits<From>::is_signed) {
      /* Both input and output are signed. */
      return static_cast<To>(std::clamp<BiggerType>(value,
          std::numeric_limits<To>::lowest(), std::numeric_limits<To>::max()));
    }
 
    /* The input is unsigned, so skip the minimum check and use unsigned variant of the biggest type as intermediate type. */
    using BiggerUnsignedType = typename std::make_unsigned<BiggerType>::type;
    return static_cast<To>(std::min<BiggerUnsignedType>(std::numeric_limits<To>::max(), value));
  }
 
  /* The output is unsigned. */
 
  if constexpr (std::numeric_limits<From>::is_signed) {
    /* Input is signed; account for the negative numbers in the input. */
    if constexpr (sizeof(To) >= sizeof(From)) {
      /* If the output type is larger or equal to the input type, then only clamp the negative numbers. */
      return static_cast<To>(std::max<From>(value, 0));
    }
 
    /* The output type is smaller than the input type. */
    using BiggerSignedType = typename std::make_signed<BiggerType>::type;
    return static_cast<To>(std::clamp<BiggerSignedType>(value,
        std::numeric_limits<To>::lowest(), std::numeric_limits<To>::max()));
  }
 
  /* The input and output are unsigned, just clamp at the high side. */
  return static_cast<To>(std::min<BiggerType>(value, std::numeric_limits<To>::max()));
}

template <typename To>
constexpr To ClampTo(ConvertibleThroughBase auto value)
{
  return ClampTo<To>(value.base());
}

template <typename T>
constexpr T Delta(const T a, const T b)
{
  return (a < b) ? b - a : a - b;
}

template <typename T>
constexpr bool IsInsideBS(const T x, const size_t base, const size_t size)
{
  return static_cast<size_t>(x - base) < size;
}

constexpr bool IsInsideMM(const size_t x, const size_t min, const size_t max) noexcept
{
  return static_cast<size_t>(x - min) < (max - min);
}

constexpr bool IsInsideMM(const ConvertibleThroughBase auto x, const size_t min, const size_t max) noexcept { return IsInsideMM(x.base(), min, max); }

template <typename enum_type, std::enable_if_t<std::is_enum_v<enum_type>, bool> = true>
constexpr bool IsInsideMM(enum_type x, enum_type min, enum_type max) noexcept
{
  return IsInsideMM(to_underlying(x), to_underlying(min), to_underlying(max));
}

constexpr uint ToPercent8(uint i)
{
  assert(i < 256);
  return i * 101 >> 8;
}

constexpr uint ToPercent16(uint i)
{
  assert(i < 65536);
  return i * 101 >> 16;
}
 
int DivideApprox(int a, int b);

constexpr uint CeilDiv(uint a, uint b)
{
  return (a + b - 1) / b;
}

constexpr uint Ceil(uint a, uint b)
{
  return CeilDiv(a, b) * b;
}

constexpr int RoundDivSU(int a, uint b)
{
  if (a > 0) {
    /* 0.5 is rounded to 1 */
    return (a + static_cast<int>(b) / 2) / static_cast<int>(b);
  } else {
    /* -0.5 is rounded to 0 */
    return (a - (static_cast<int>(b) - 1) / 2) / static_cast<int>(b);
  }
}

constexpr uint64_t PowerOfTen(int power)
{
  assert(power >= 0 && power <= 20 /* digits in uint64_t */);
  uint64_t result = 1;
  for (int i = 0; i < power; i++) result *= 10;
  return result;
}
 
uint32_t IntSqrt(uint32_t num);
 
#endif /* MATH_FUNC_HPP */