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