A C++ template library for embedded applications
Designed and maintained by
Aster Consulting Ltd
Join the ETL community

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