math.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <bit>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <limits>
#include <numeric>
#include <type_traits>
#include <utility>
 
#include <rex/assert.h>
#include <rex/platform.h>
#include <rex/types.h>
 
namespace rex {
 
template <typename T, size_t N>
constexpr size_t CountOf(T (&)[N]) noexcept {
  return std::extent<T[N]>::value;
}

template <typename T>
constexpr T RoundUpPow2(T value, T alignment) {
  return (value + alignment - 1) & ~(alignment - 1);
}

template <typename T, typename V>
constexpr T RoundUp(T value, V multiple) {
  return (value + multiple - 1) / multiple * multiple;
}

template <typename T, typename V>
constexpr T RoundUpNonZero(T value, V multiple) {
  if (!value) {
    return multiple;
  }
  return RoundUp(value, multiple);
}

template <typename T>
T clamp_float(T value, T min_value, T max_value) {
  f32 clamped_to_min = std::isgreater(value, min_value) ? value : min_value;
  return std::isless(clamped_to_min, max_value) ? clamped_to_min : max_value;
}

template <typename T>
T saturate(T value) {
  return clamp_float(value, static_cast<T>(0.0f), static_cast<T>(1.0f));
}

template <typename T>
constexpr void reduce_fraction(T& numerator, T& denominator) {
  auto gcd = std::gcd(numerator, denominator);
  numerator /= gcd;
  denominator /= gcd;
}

template <typename T>
constexpr void reduce_fraction(std::pair<T, T>& fraction) {
  reduce_fraction<T>(fraction.first, fraction.second);
}

constexpr u64 mul_div(u64 value, u64 numerator, u64 denominator) {
  REX_ASSERT(denominator != 0);
  constexpr u64 kMax = std::numeric_limits<u64>::max();
  constexpr u64 kHalfMask = 0xFFFFFFFF;
  if (denominator == 0) {
    return kMax;
  }
  const unsigned __int128 product = static_cast<unsigned __int128>(value) * numerator;
  u64 high = static_cast<u64>(product >> 64);
  u64 low = static_cast<u64>(product);
  if (high >= denominator) {
    return kMax;
  }
  if (high == 0) {
    return low / denominator;
  }
 
  const int shift = std::countl_zero(denominator);
  denominator <<= shift;
  high = (high << shift) | (shift == 0 ? 0 : low >> (64 - shift));
  low <<= shift;
  const u64 divisor_high = denominator >> 32;
  const u64 divisor_low = denominator & kHalfMask;
 
  const auto divide_step = [&](u64 dividend, u64 next_half) {
    u64 quotient = dividend / divisor_high;
    u64 remainder = dividend % divisor_high;
    while ((quotient >> 32) != 0 || quotient * divisor_low > ((remainder << 32) | next_half)) {
      --quotient;
      remainder += divisor_high;
      if ((remainder >> 32) != 0) {
        break;
      }
    }
    return quotient;
  };
 
  const u64 low_high = low >> 32;
  const u64 quotient_high = divide_step(high, low_high);
  const u64 partial = ((high << 32) | low_high) - quotient_high * denominator;
  const u64 quotient_low = divide_step(partial, low & kHalfMask);
  return (quotient_high << 32) | quotient_low;
}

template <typename T>
inline T SatAdd(T a, T b) {
  using TU = std::make_unsigned<T>::type;
  TU result = static_cast<TU>(a) + static_cast<TU>(b);
  if (std::is_unsigned<T>::value) {
    result |= static_cast<TU>(-static_cast<std::make_signed<T>::type>(result < static_cast<TU>(a)));
  } else {
    TU overflowed = (static_cast<TU>(a) >> (sizeof(T) * 8 - 1)) + std::numeric_limits<T>::max();
    if (static_cast<T>((overflowed ^ static_cast<TU>(b)) | ~(static_cast<TU>(b) ^ result)) >= 0) {
      result = overflowed;
    }
  }
  return static_cast<T>(result);
}

template <typename T>
inline T SatSub(T a, T b) {
  using TU = std::make_unsigned<T>::type;
  TU result = static_cast<TU>(a) - static_cast<TU>(b);
  if (std::is_unsigned<T>::value) {
    result &=
        static_cast<TU>(-static_cast<std::make_signed<T>::type>(result <= static_cast<TU>(a)));
  } else {
    TU overflowed = (static_cast<TU>(a) >> (sizeof(T) * 8 - 1)) + std::numeric_limits<T>::max();
    if (static_cast<T>((overflowed ^ static_cast<TU>(b)) & (overflowed ^ result)) < 0) {
      result = overflowed;
    }
  }
  return static_cast<T>(result);
}

struct Vec2 {
  f32 x = 0;
  f32 y = 0;
 
  constexpr bool operator==(const Vec2& other) const = default;
};
 
}  // namespace rex