bit

Returns the number x arithmetically shifted disp bits to the right.

Unlike bit.rshift, the vacated high-order bits are filled with copies of the sign bit of x rather than zeros, so the sign of the value is preserved.

Negative displacements shift to the left, behaving identically to bit.lshift in that case.

    1111 1000   -8  (as a signed 8-bit value)
ARSH 0000 0010   2
_____________
    1111 1110   -2

Returns the bitwise AND of all provided values.

Each bit is tested against the following truth table:

    1100 1110   222
    0101 1000   88
AND 0100 1001   73
_____________
    0100 1000   72

Returns the bitwise NOT ( negation ) of x.

Inverts every bit of the 32-bit integer.

NOT 1111 0000   240
_____________
    0000 1111   15

<br/>

For any integer x, the following identity holds:

assert( bit.bnot( x ) == ( -1 - x ) % 2 ^ 32 )
````

Returns the bitwise OR of all provided values.

Each bit is tested against the following truth table:

    0101 0001   81
    0001 0101   21
OR  0000 0101   5
_____________
    0101 0101   85

Swaps the byte order of a 32-bit integer.

Returns whether the bitwise AND of all provided values is non-zero, i.e. whether x and every value in ... have at least one bit in common.

Equivalent to bit.band( x, ... ) ~= 0, but without needing to look at the result.

Returns the bitwise XOR of all provided numbers.

Each bit is tested against the following truth table:

<br/>

    0101 0001   81
    0001 0101   21
XOR 0000 0101   5
_____________
    0100 0001   65

Counts the number of leading zero bits in x, starting from the most significant bit of the bit_count-bit window and stopping at the first 1 bit.

Returns bit_count if x is zero (i.e. all bits within the window are zero).

Counts the number of trailing zero bits in x, starting from the least significant bit and stopping at the first 1 bit.

Returns bit_count if x is zero (i.e. all bits within the window are zero).

Extracts a bit field of the given width from x, starting at bit position field (0-indexed, counted from the least significant bit).

Equivalent to shifting x right by field bits and then masking off everything above width bits.

extract( 0b10110100, 2, 3 ) --> 0b101 ( 5 )

Returns the number x shifted disp bits to the left.

The number disp may be any representable integer.

Negative displacements shift to the right.

In any direction, vacant bits are filled with zeros.

In particular, displacements with absolute values higher than 31 result in zero (all bits are shifted out).

    0000 1111   15
LSH 0000 0011   3
_____________
    0111 1000   120

NOTE: The returned value will be clamped to a signed 32-bit integer, even on 64-bit builds.

See this wiki article for more details.

Bitwise majority function. For each bit position, returns 1 if at least two of the three corresponding bits of a, b and c are 1, and 0 otherwise.

Equivalent to (a & (b | c)) | (b & c), and often used as the Maj function in hash algorithms such as SHA-2.

Bitwise multiplexer (also known as "choose"). For each bit position, selects the corresponding bit of b where a is 1, and the corresponding bit of c where a is 0.

Equivalent to c ~ (a & (b ~ c)), and often used as the Ch function in hash algorithms such as SHA-2.

Replaces a bit field of the given width in x, starting at bit position field (0-indexed, counted from the least significant bit), with the low width bits of extract.

All bits of x outside the targeted field are left unchanged.

Reverses the order of the lowest bit_count bits of x, so the least significant bit becomes the most significant bit (within that range) and vice versa.

reverse( 0b1011000, 7 ) --> 0b0001101

Returns the number x rotated disp bits to the left.

The number disp may be any representable integer.

For any valid displacement, the following identity holds:

assert( bit.lrotate( x, disp ) == bit.lrotate( x, disp % 32 ) )

Returns the number x rotated disp bits to the right.

The number disp may be any representable integer.

For any valid displacement, the following identity holds:

assert( bit.rrotate( x, disp ) == bit.rrotate( x, disp % 32 ) )

In particular, negative displacements rotate to the left.

Returns the number x shifted disp bits to the right.

The number disp may be any representable integer.

Negative displacements shift to the left. In any direction, vacant bits are filled with zeros.

In particular, displacements with absolute values higher than 31 result in zero (all bits are shifted out).

    0111 1000   120
RSH 0000 0011   3
_____________
    0000 1111   15

NOTE: The returned value will be clamped to a signed 32-bit integer, even on 64-bit builds.

See this wiki article for more details.

Returns the sign of an integer.

Normalizes the specified value to a signed 32-bit integer by wrapping it around modulo 2^32, so values outside the range are not clamped.

rbit.tobit( 0xFFFFFFFF ) -- -1
rbit.tobit( 2 ^ 32 + 5 ) -- 5

Returns the lowercase hexadecimal representation of the number, zero-padded to length digits.

rbit.tohex( 255 ) -- "000000ff"
rbit.tohex( 255, 2 ) -- "ff"

Returns the unsigned value of an integer.

Returns the number of bits needed to store x as an unsigned bit_count-bit integer, i.e. the position of its highest set bit plus one.

Equivalent to bit_count - bit.clz( x, bit_count ), returns 0 if x is zero.

bit.width( 0 )    --> 0
bit.width( 255 )  --> 8
bit.width( 256 )  --> 9