data.bits ≡

Rotate the specified value left by the specified amount.

>>> rotl(0x9, 0);
0x9

>>> rotl(0x9, 1);
0x3

>>> rotl(0x9, 2);
0x6

>>> rotl(0x9, 3);
0xC

Rotate the specified value right by the specified amount.

>>> rotr(0x9, 0);
0x9

>>> rotr(0x9, 1);
0xC

>>> rotr(0x9, 2);
0x6

>>> rotr(0x9, 3);
0x3

Find the index of the highest 1 bit in the value. The result is an optional<bitindex_t<T>> with the is_valid field indicating if there are any 1 bits in the value. When is_valid is true then value is the index of the highest 1 bit.

>>> highest_one(0);
{0x0, 0x0}

>>> highest_one(1);
{0x1, 0x0}

>>> highest_one(0x32);
{0x1, 0x5}

Find the index of the lowest 1 bit in the value. The result is an optional<bitindex_t<T>> with the is_valid field indicating if there are any 1 bits in the value. When is_valid is true then value is the index of the lowest 1 bit.

>>> lowest_one(0);
{0x0, 0x0}

>>> lowest_one(1);
{0x1, 0x0}

>>> lowest_one(0x34);
{0x1, 0x2}

Return a count of the number of bits set in the value.

>>> pop_count(0);
0x0

>>> pop_count(1);
0x1

>>> pop_count(0x34);
0x3

Divide dividend by divisor and round the result up. Divisor must be an unsigned power of 2, known at compile time. Calling with (x, 32) returns the equivalent of (x + 31) / 32.

>>> divide_and_roundup(0, 0x20);
0x0

>>> divide_and_roundup(1, 0x20);
0x1

>>> divide_and_roundup(0x20, 0x20);
0x1

>>> divide_and_roundup(0x81f, 0x40);
0x21

Round up a value to the next larger power of two. For example, all values from 33 through 64 (inclusive) round up to 64. OutputType must be at least one bit larger than InputType.

>>> roundup_to_pow2<uint15, uint16>(0);
{0x0, 0x0}

>>> roundup_to_pow2<int7, int8>(0x1f);
{0x1, 0x20}

>>> roundup_to_pow2<uint7, uint8>(0x20);
{0x1, 0x20}

>>> roundup_to_pow2<uint15, uint16>(0x21);
{0x1, 0x40}

Reverse all bits and return the same input data type.

>>> reverse(0xC);
0x3

>>> reverse<optional<uint1>>({false, 0x1});
{0x1, 0x0}

>>> reverse<uint2[4]>({0, 1, 2, 3});
{0x3, 0x1, 0x2, 0x0}

Reverse input byte-by-byte and return as the same data type.

>>> reverse_bytes<uint8>(0xC);
0xC

>>> reverse_bytes<uint32>(0xB01DFACE);
0xCEFA1DB0

>>> reverse_bytes<uint8[4]>({0, 1, 2, 3});
{0x3, 0x2, 0x1, 0x0}

Return array bool[N] with element at i the result of i >= arg.

>>> mask_greater_equal<4>(2);
{0x0, 0x0, 0x1, 0x1}

Return array bool[N] with element at i the result of i < arg.

>>> mask_less_than<4>(2);
{0x1, 0x1, 0x0, 0x0}

Return array bool[N] with element at i the result of i > arg.

>>> mask_greater_than<4>(2);
{0x0, 0x0, 0x0, 0x1}

Return array bool[N] with element at i the result of i <= arg.

>>> mask_less_equal<4>(2);
{0x1, 0x1, 0x1, 0x0}

Casts the specified scalar type to an array of booleans and applies the reduction operator to it

Verilog style AND reduction operator

Verilog style OR reduction operator

Verilog style XOR reduction operator

Verilog style XNOR reduction operator

Verilog style NAND reduction operator

Verilog style NOR reduction operator

AND operator applied to the bits of an arbitrary type.

OR operator applied to the bits of an arbitrary type.

XOR operator applied to the bits of an arbitrary type.

NAND operator applied to the bits of an arbitrary type.

NOR operator applied to the bits of an arbitrary type.

XNOR operator applied to the bits of an arbitrary type.