Math.hpp

Go to the documentation of this file.

/*
 * Copyright 2023 Håvard Krogstie <krogstie.havard@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_UTIL_MATH_HPP
#define JLM_UTIL_MATH_HPP
 
#include <type_traits>
 
namespace jlm::util
{
 
template<class T>
static constexpr int
log2Floor(T value)
{
  static_assert(std::is_integral_v<T>, "T must be integral type");
  if (value < 1)
    return -1;
 
  return 1 + log2Floor(value >> 1);
}
 
template<class T>
static constexpr T
RoundUpToPowerOf2(T value)
{
  // 2^0 == 1 is the lowest possible power of two
  if (value <= 1)
    return 1;
 
  return T(1) << (log2Floor(value - 1) + 1);
}
 
template<class T>
static constexpr T
RoundUpToMultipleOf(T value, T multiple)
{
  const auto miss = value % multiple;
  if (miss < 0)
    return value - miss;
  if (miss == 0)
    return value;
  return value + multiple - miss;
}
 
template<class T>
static constexpr int
BitsRequiredToRepresent(T value)
{
  using UnsignedT = std::make_unsigned_t<T>;
  return log2Floor(static_cast<UnsignedT>(value)) + 1;
}
 
template<class T>
static constexpr int
BitWidthOfEnum(T endValue)
{
  static_assert(std::is_enum_v<T>, "BitWidthOfEnum only takes enums");
 
  using UnderlyingT = std::underlying_type_t<T>;
 
  // To appease gcc warnings, the returned bit width is large enough to hold the endValue as well,
  // even if it is just a sentinel COUNT value
  return BitsRequiredToRepresent(static_cast<UnderlyingT>(endValue));
}
 
}
 
#endif // JLM_UTIL_MATH_HPP