A C++ template library for embedded applications
Designed and maintained by
Aster Consulting Ltd

Binary

Utility functions for manipulating binary numbers.

Rotate

Rotate the bits in the value left or right.

template <typename T>
T rotate_left(T value)

template <typename T>
T rotate_left(T value, size_t distance)

template <typename T>
T rotate_right(T value)

template <typename T>
T rotate_right(T value, size_t distance)

template <typename T>
T rotate(T value, typename etl::make_signed<size_t>::type distance)


Reverse bits

Reverse the order of the bits in a value.

uint8_t reverse_bits(uint8_t value)
int8_t reverse_bits(int8_t value)

uint16_t reverse_bits(uint16_t value)
int16_t reverse_bits(int16_t value)

uint32_t reverse_bits(uint32_t value)
int32_t reverse_bits(int32_t value)

uint64_t reverse_bits(uint64_t value)
int64_t reverse_bits(int64_t value)


Reverse bytes

Reverse the order of the bytes in a value.

uint8_t reverse_bytes(uint8_t value)
int8_t reverse_bytes(int8_t value)

uint16_t reverse_bytes(uint16_t value)
int16_t reverse_bytes(int16_t value)

uint32_t reverse_bytes(uint32_t value)
int32_t reverse_bytes(int32_t value)

uint64_t reverse_bytes(uint64_t value)
int64_t reverse_bytes(int64_t value)


Gray to binary

Converts a gray code value to binary.

uint8_t gray_to_binary(uint8_t value)
int8_t gray_to_binary(int8_t value);

uint16_t gray_to_binary(uint16_t value)
int16_t gray_to_binary(int16_t value)

uint32_t gray_to_binary(uint32_t value)
int32_t gray_to_binary(int32_t value)

uint64_t gray_to_binary(uint64_t value)
int64_t gray_to_binary(int64_t value)


Binary to gray

Converts a binary value to the gray code equivalent.

template <typename T>
T binary_to_gray(T value)


Count bits

Counts the number of set bits in a value.

uint_least8_t count_bits(uint8_t value)
uint_least8_t count_bits(int8_t value)

uint_least8_t count_bits(uint16_t value)
uint_least8_t count_bits(int16_t value)

uint_least8_t count_bits(uint32_t value)
uint_least8_t count_bits(int32_t value)

uint_least8_t count_bits(uint64_t value)
uint_least8_t count_bits(int64_t value)


Parity

Returns 1 if the parity of the value is odd, 0 if it is even.


uint_least8_t parity(uint8_t value)
uint_least8_t parity(int8_t value)
uint_least8_t parity(uint16_t value)
uint_least8_t parity(int16_t value)
uint_least8_t parity(uint32_t value)
uint_least8_t parity(int32_t value)
uint_least8_t parity(uint64_t value)
uint_least8_t parity(int64_t value)


Max value for N bits

Returns maximum unsigned value a particular number of bits can represent.

template <const size_t NBITS>
struct max_value_for_nbits
value_type The type for the value.
value      The maximum value.


Fold

Fold a binary number down to a set number of bits using XOR.

template <typename TReturn, const size_t NBITS, typename TValue>
TReturn fold_bits(TValue value)

Example:
0xE8C9AACCBC3D9A8F folded down to 20 bits = 0x998E8

uint32_t result = etl::fold_bits<uint32_t, 20>(0xE8C9AACCBC3D9A8F);


Sign extend

Sign extends a binary number.
template <typename TReturn, const size_t NBITS, typename TValue>
TReturn sign_extend(TValue value)

template <typename TReturn, typename TValue>
TReturn sign_extend(TValue value, const size_t NBITS)


Count trailing zeros

Counts the number of trailing zeros in a binary number

uint_least8_t count_trailing_zeros(uint8_t value)
uint_least8_t count_trailing_zeros(int8_t value)
uint_least8_t count_trailing_zeros(uint16_t value)
uint_least8_t count_trailing_zeros(int16_t value)
uint_least8_t count_trailing_zeros(uint32_t value)
uint_least8_t count_trailing_zeros(int32_t value)
uint_least8_t count_trailing_zeros(uint64_t value)
uint_least8_t count_trailing_zeros(int64_t value)


First set position

Finds the index of the first set bit from lsb.

template <typename T>
uint_least8_t first_set_bit_position(T value)


First clear position

Finds the index of the first clear bit from lsb.

template <typename T>
uint_least8_t first_clear_bit_position(T value)


First position of bit in the specified state

Finds the index of the first bit in the specified state, from lsb.

template <typename T>
uint_least8_t first_bit_position(bool state, T value)


Fill a binary value with a pattern

Fills a value of the specified width with a repeating binary pattern.

Compile time

template <typename TResult, typename TValue, const TValue VALUE>
class binary_fill

Generate 0x12121212
etl::binary_fill<uint32_t, uint8_t, 0x12>::value

Run time

template <typename TResult>
class binary_fill

Generate 0x12121212
etl::binary_fill<uint32_t>::value(uint8_t(0x12));


Check a binary value for a zero byte

Checks to see if a value contains a byte of value zero.

Compile time

template <typename TValue, const TValue VALUE>
class has_zero_byte

etl::has_zero_byte<uint32_t, 0x01234567>::test false
etl::has_zero_byte<uint32_t, 0x01230067>::test true

Run time

template <>
class has_zero_byte

etl::has_zero_byte<>::test(uint32_t(0x01234567)) false
etl::has_zero_byte<>::test(uint32_t(0x01230067)) true


Check a binary value for a particular value byte

Checks to see if a value contains a byte of a particular value.

Compile time

template <const uint8_t N, typename TValue, const TValue VALUE>
class has_byte_n

etl::has_byte_n<0x12, uint32_t, 0x01234567>::test false
etl::has_byte_n<0x45, uint32_t, 0x01234567>::test true

Run time

template <const uint8_t N>
class has_byte_n

etl::has_byte_n<0x12>::test(uint32_t(0x01234567)) false
etl::has_byte_n<0x45>::test(uint32_t(0x01234567)) true

Run time

template <>
class has_byte_n

etl::has_byte_n<>::test(uint32_t(0x01234567), 0x12) false
etl::has_byte_n<>::test(uint32_t(0x01234567), 0x45) true


Merge two values

Merges two binary values according to a mask.
Bits set in the mask select bits in the first value, clear bits select those in the second.

template <typename T>
T binary_merge(const T first, const T second, const T mask)

uint8_t first  = 0x12;
uint8_t second = 0x34;

const uint8_t mask = 0xF0;

etl::binary_merge(first, second, mask) Equals 0x14

template <typename T, const T MASK>
T binary_merge(const T first, const T second)

uint8_t first  = 0x12;
uint8_t second = 0x34;

const uint8_t mask = 0xF0;

etl::binary_merge<uint8_t, mask>(first, second) Equals 0x14


Interleave two values

Interleaves two values such that bits abcd and efgh will result in eafbgchd.

uint16_t binary_interleave(uint8_t first, uint8_t second);
int16_t binary_interleave(int8_t first, int8_t second);
uint32_t binary_interleave(uint16_t first, uint16_t second);
int32_t binary_interleave(int16_t first, int16_t second);
uint64_t binary_interleave(uint32_t first, uint32_t second);
int64_t binary_interleave(int32_t first, int32_t second);


Odd / Even

Determines the odd or evenness of a value.

bool is_odd(const unsigned char value);
bool is_odd(const char value);

bool is_odd(const unsigned short value);
bool is_odd(const short value);

bool is_odd(const unsigned int value);
bool is_odd(const int value);

bool is_odd(const unsigned long value);
bool is_odd(const long value);

bool is_odd(const unsigned long long value);
bool is_odd(const long long value);


Constants

enum binary_constant
An enumeration of 256 constants from b00000000 to b11111111 (0 to 255)

enum bit_constant
An enumeration of 32 constants from b0 to b31 (1 to 4294967296)

template <const size_t POSITION>
struct bit
value_type The type of the value.
value      The value of the bit at POSITION.
binary.h