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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef MATH_FUNC_HPP
#define MATH_FUNC_HPP
 
template <typename T>
static inline T abs(const T a)
{
  return (a < (T)0) ? -a : a;
}
 
template <typename T>
static inline T Align(const T x, uint n)
{
  assert((n & (n - 1)) == 0 && n != 0);
  n--;
  return (T)((x + n) & ~((T)n));
}
 
template <typename T>
static inline T *AlignPtr(T *x, uint n)
{
  static_assert(sizeof(size_t) == sizeof(void *));
  return reinterpret_cast<T *>(Align((size_t)x, n));
}
 
template <typename T>
static inline 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>
static inline 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;
}
 
static inline int Clamp(const int a, const int min, const int max)
{
  return Clamp<int>(a, min, max);
}
 
static inline uint ClampU(const uint a, const uint min, const uint max)
{
  return Clamp<uint>(a, min, max);
}
 
static inline int32 ClampToI32(const int64 a)
{
  return static_cast<int32>(Clamp<int64>(a, INT32_MIN, INT32_MAX));
}
 
static inline uint16 ClampToU16(const uint64 a)
{
  /* MSVC thinks, in its infinite wisdom, that int min(int, int) is a better
   * match for min(uint64, uint) than uint64 min(uint64, uint64). As such we
   * need to cast the UINT16_MAX to prevent MSVC from displaying its
   * infinite loads of warnings. */
  return static_cast<uint16>(std::min(a, static_cast<uint64>(UINT16_MAX)));
}
 
template <typename T>
static inline T Delta(const T a, const T b)
{
  return (a < b) ? b - a : a - b;
}
 
template <typename T>
static inline bool IsInsideBS(const T x, const size_t base, const size_t size)
{
  return (size_t)(x - base) < size;
}
 
template <typename T>
static constexpr inline bool IsInsideMM(const T x, const size_t min, const size_t max) noexcept
{
  return (size_t)(x - min) < (max - min);
}
 
template <typename T>
static inline void Swap(T &a, T &b)
{
  T t = a;
  a = b;
  b = t;
}
 
static inline uint ToPercent8(uint i)
{
  assert(i < 256);
  return i * 101 >> 8;
}
 
static inline uint ToPercent16(uint i)
{
  assert(i < 65536);
  return i * 101 >> 16;
}
 
int LeastCommonMultiple(int a, int b);
int GreatestCommonDivisor(int a, int b);
int DivideApprox(int a, int b);
 
static inline uint CeilDiv(uint a, uint b)
{
  return (a + b - 1) / b;
}
 
static inline uint Ceil(uint a, uint b)
{
  return CeilDiv(a, b) * b;
}
 
static inline 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);
  }
}
 
static inline int DivAwayFromZero(int a, uint b)
{
  const int _b = static_cast<int>(b);
  if (a > 0) {
    return (a + _b - 1) / _b;
  } else {
    /* Note: Behaviour of negative numerator division is truncation toward zero. */
    return (a - _b + 1) / _b;
  }
}
 
uint32 IntSqrt(uint32 num);
 
#endif /* MATH_FUNC_HPP */