utils.h

Go to the documentation of this file.

#ifndef ION_MATH_UTILS_H_
#define ION_MATH_UTILS_H_


#include <algorithm>
#include <cmath>

#include "base/integral_types.h"

namespace ion {
namespace math {

template <typename T>
inline bool IsFinite(T x) {
  return (x == x &&
          x != std::numeric_limits<T>::infinity() &&
          x != -std::numeric_limits<T>::infinity());
}

template <typename T>
inline const T Abs(const T& val) {
  return val >= static_cast<T>(0) ? val : -val;
}

template <typename T>
inline const T Square(const T& val) {
  return val * val;
}

template <typename T>
inline T Sqrt(const T& val) {
  return static_cast<T>(sqrt(static_cast<double>(val)));
}
template <>
inline float Sqrt(const float& val) {
  return sqrtf(val);
}

template <typename T>
inline T Cosine(T angle) {
  return cos(angle);
}
template <>
inline float Cosine(float angle) {
  return cosf(angle);
}

template <typename T>
inline T Sine(T angle) {
  return sin(angle);
}
template <>
inline float Sine(float angle) {
  return sinf(angle);
}

template <typename T>
inline T Tangent(T angle) {
  return tan(angle);
}
template <>
inline float Tangent(float angle) {
  return tanf(angle);
}

template <typename T>
inline T Factorial(int x) {
  if (x < 0) return 0;
  T result = 1;
  for (; x > 0; x--) result *= x;
  return result;
}

template <typename T>
inline T DoubleFactorial(int x) {
  if (x < 0) return 0;
  T result = 1;
  for (; x > 0; x -= 2) result *= x;
  return result;
}

inline uint32 NextPowerOf2(uint32 n) {
  if (n == 0) return 0;
  n -= 1;
  n |= n >> 16;
  n |= n >> 8;
  n |= n >> 4;
  n |= n >> 2;
  n |= n >> 1;
  return n + 1;
}
inline uint64 NextPowerOf2(uint64 n) {
  if (n == 0) return 0;
  n -= 1;
  n |= n >> 32;
  n |= n >> 16;
  n |= n >> 8;
  n |= n >> 4;
  n |= n >> 2;
  n |= n >> 1;
  return n + 1;
}

template <typename T>
inline T Log2(T n) {
  static const T kInverseOfLogOf2 = static_cast<T>(1.4426950408889634);
  return static_cast<T>(log(n) * kInverseOfLogOf2);
}
template <>
inline uint32 Log2(uint32 n) {
  static const uint32 kMultiplyDeBruijnBitPosition[32] = {
      0, 9,  1,  10, 13, 21, 2,  29, 11, 14, 16, 18, 22, 25, 3, 30,
      8, 12, 20, 28, 15, 17, 24, 7,  19, 27, 23, 6,  26, 5,  4, 31};

  n |= n >> 1;  // First round down to one less than a power of 2.
  n |= n >> 2;
  n |= n >> 4;
  n |= n >> 8;
  n |= n >> 16;

  return kMultiplyDeBruijnBitPosition[(n * 0x07C4ACDDU) >> 27];
}
template <>
inline int Log2(int n) {
  if (n <= 0)
    return 0;
  else
    return Log2(static_cast<uint32>(n));
}
template <>
inline uint64 Log2(uint64 n) {
  const uint32 kMultiplyDeBruijnBitPosition[64] = {
      63, 0,  58, 1,  59, 47, 53, 2,  60, 39, 48, 27, 54, 33, 42, 3,
      61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22, 4,
      62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21,
      56, 45, 25, 31, 35, 16, 9,  12, 44, 24, 15, 8,  23, 7,  6,  5};
  n |= n >> 1;  // First round down to one less than a power of 2.
  n |= n >> 2;
  n |= n >> 4;
  n |= n >> 8;
  n |= n >> 16;
  n |= n >> 32;
  n -= n >> 1;

  return kMultiplyDeBruijnBitPosition[(n * 0x07EDD5E59A4E28C2ULL) >> 58];
}
template <>
inline int64 Log2(int64 n) {
  if (n <= 0)
    return 0;
  else
    return Log2(static_cast<uint64>(n));
}

template <typename T>
inline const T Clamp(const T& val, const T& min_val, const T& max_val) {
  return std::min(std::max(val, min_val), max_val);
}

template<typename T, typename U>
inline const U Lerp(const U& begin, const U& end, const T& t) {
  return static_cast<U>(begin + t * (end - begin));
}

inline bool IsPowerOfTwo(int value) {
  return (value != 0) && ((value & (value - 1)) == 0);
}

}  // namespace math
}  // namespace ion

#endif  // ION_MATH_UTILS_H_