> For the complete documentation index, see [llms.txt](https://developers.brickverse.gg/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developers.brickverse.gg/bricklua-coding-with-lua/learn-lua/bit32.md). # bit32 ## bit32 This library is a back-ported [feature from Lua 5.2](https://www.lua.org/manual/5.2/manual.html#6.7) which provides functions to perform bitwise operations. | number **bit32.arshift** ( number x, number disp ) | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |

Returns the number x shifted disp bits to the right. The number disp may be any representable integer. Negative displacements shift to the left.

This shift operation is what is called arithmetic shift. Vacant bits on the left are filled with copies of the higher bit of x; vacant bits on the right are filled with zeros. In particular, displacements with absolute values higher than 31 result in zero or 0xFFFFFFFF (all original bits are shifted out).

| | number **bit32.band** ( Tuple numbers ) | | ------------------------------------------ | | Returns the bitwise *and* of its operands. |
number bit32.bnot ( number x )

Returns the bitwise negation of x. For any integer x, the following identity holds:

assert(bit32.bnot(x) == (-1 - x) % 2^32)
| number **bit32.bor** ( Tuple numbers ) | | ----------------------------------------- | | Returns the bitwise *or* of its operands. | | boolean **bit32.btest** ( Tuple numbers ) | | ---------------------------------------------------------------------------------------------- | | Returns a boolean signalling whether the bitwise *and* of its operands is different from zero. | | number **bit32.bxor** ( Tuple numbers ) | | --------------------------------------------------- | | Returns the bitwise *exclusive or* of its operands. | | number **bit32.extract** ( number n, number field, number width = 1 ) | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Returns the unsigned number formed by the bits `field` to `field + width - 1` from `n`. Bits are numbered from 0 (least significant) to 31 (most significant). All accessed bits must be in the range \[0, 31]. The default for `width` is 1. | | number **bit32.replace** ( number n, number v, number field, number width = 1 ) | | -------------------------------------------------------------------------------------------------------------------------------------------------------- | | Returns a copy of `n` with the bits `field` to `field + width - 1` replaced by the value `v`. See `bit32.extract` for details about `field` and `width`. |
number bit32.lrotate ( number x, number disp )

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(bit32.lrotate(x, disp) == bit32.lrotate(x, disp % 32))

In particular, negative displacements rotate to the right.

number bit32.lshift ( number x, number disp )

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).

For positive displacements, the following equality holds:

assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
number bit32.rrotate ( number x, number disp )

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(bit32.rrotate(x, disp) == bit32.rrotate(x , disp % 32))

In particular, negative displacements rotate to the left.

number bit32.rshift ( number x, number disp )

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).

For positive displacements, the following equality holds:

assert(bit32.rshift(b, disp) == math.floor(b % 2^32 / 2^disp))

This shift operation is what is called logical shift.