bit.h

Go to the documentation of this file.

#ifndef UTL_BIT_H
#define UTL_BIT_H
 
#include <bit>
 
namespace utl {

template <class T>
constexpr auto bit_size() {
  return sizeof(T) * 8;
}

template <class T>
constexpr T bit_full() {
  return T(-1);
}

template <class T>
constexpr T bit_wrap() {
  return bit_size<T>() - 1;
}

template <class T>
constexpr auto bit_shft() {
  return std::bit_width(bit_wrap<T>());
}

template <class T>
constexpr auto bit_ceil(auto x) {
  return (x + bit_wrap<T>()) >> bit_shft<T>();
}

constexpr unsigned cntlz(auto x) {
  if constexpr (std::is_same_v<decltype(x), int>)
    return std::countl_zero(unsigned(x));
  else
    return std::countl_zero(x);
}

constexpr unsigned cnttz(auto x) {
  if constexpr (std::is_same_v<decltype(x), int>)
    return std::countr_zero(unsigned(x));
  else
    return std::countr_zero(x);
}

template <class T>
constexpr size_t words_in_bits(size_t n) {
  return (n >> bit_shft<T>()) + !!(n & bit_wrap<T>());
}

constexpr size_t bytes_in_bits(size_t n) {
  return words_in_bits<uint8_t>(n);
}

template <class T = unsigned>
constexpr T bit(int n) {
  return T(1) << n;
}

template <class T>
constexpr bool get_bit(T x, int n) {
  return (x >> n) & 1;
}

template <class T>
constexpr void set_bit(T& x, int n) {
  x |= 1 << n;
}

template <class T>
constexpr void clr_bit(T& x, int n) {
  x &= ~(1 << n);
}

template <class T>
constexpr bool get_arr_bit(const T* p, unsigned n) {
  return get_bit(p[n >> bit_shft<T>()], n & bit_wrap<T>());
}

template <class T>
constexpr void set_arr_bit(T* p, unsigned n) {
  set_bit(p[n >> bit_shft<T>()], n & bit_wrap<T>());
}

template <class T>
constexpr void clr_arr_bit(T* p, unsigned n) {
  clr_bit(p[n >> bit_shft<T>()], n & bit_wrap<T>());
}

template <class T, size_t L>
constexpr void shift_left(T (&x)[L]) {
  for (int i = L - 1; i > 0; --i) {
    x[i] <<= 1;
    x[i] |= x[i - 1] >> bit_wrap<T>();
  }
  x[0] <<= 1;
}
 
}  // namespace utl
 
#endif