bitwise

Bitwise operations

and: <a, b>(left: a, right: b) => external_and<a, b>

The call Bitiwise.and a b is the conjunction defined on boolean, natural number and bytes operands. In the boolean case, the result is the logical "and" of the operands. In the natural number and bytes cases, the result is the bitwise "and" of the operands.

The function Bitwise.and is also defined when the left operand is of type int. Negative numbers are considered in two's complement representation, starting with a virtual infinite number of 1s.

When Bitwise.and is used for bytes operands, the bytes result has the same length as the shorter operand. The prefix of the longer operand is cut to match with the length of the shorter one before taking the bitwise "and".

or: <a, b>(left: a, right: b) => external_or<a, b>

The call Bitwise.or a b is the disjunction defined on boolean, natural number and bytes operands. In the boolean case, the result is the logical "or" of the operands. In the natural number and bytes cases, the result is the bitwise "or" of the operands.

When the function Bitwise.or is used for bytes operands, the result bytes has the same length as the longer operand. The shorter operand is zero-padded on the left to match with the length of the longer one before taking the bitwise "or".

xor: <a, b>(left: a, right: b) => external_xor<a, b>

The call Bitwise.xor a b is the exclusive disjunction defined on boolean, natural number and bytes operands. In the boolean case, the result is the logical "exclusive or" of the operands. In the natural number and bytes cases, the result is the bitwise "xor" of the operands.

When Bitwise.xor is used for bytes operands, the result bytes has the same length as the longer operand. The shorter operand is zero-padded on the left to match with the length of the longer one before taking the bitwise "xor".

shift_left: <a, b>(left: a, right: b) => external_lsl<a, b>

The function Bitwise.shift_left on natural numbers consumes two natural numbers and produces the first number logically left-shifted by the second number. This instruction is only defined if the second number is less than or equal to 256.

For bytes, the function Biwise.shift_left consumes one byte sequence and one natural number, and produces the bytes logically left-shifted by the natural number. The vacated bits on the right are filled with zeros. The shifted bits are minimally zero-padded on the left in order to keep all the original bits, regardless if they are 0 or 1: for example, Bitwise.shift_left 0x1234 1 is 0x002468, instead of 0x2468 (even though in this case no significant bit would be lost) or 0x00002468 (where padding is not minimal). The length of the bytes returned by Bitwise.shift_left is l + (s + 7) / 8 bytes where l is the length of the original bytes and s is the natural number. This instruction is only defined if the second number is less than or equal to 64000.

shift_right: <a, b>(left: a, right: b) => external_lsr<a, b>

The function Bitwise.shift_right on natural numbers consumes two natural numbers and produces the first number logically right-shifted by second number. This function is only defined if the second number is less than or equal to 256.

For bytes, the function Bitwise.shift_right consumes one chunk of bytes and one natural number and produces the bytes logically right-shifted by the natural number. The shifted bits are minimally zero-padded on the left. For example, Bitwise.shift_right 0x012349 9 is 0x0091, instead of 0x91 (where the 7 left-most bits are lost) or 0x000091 (not minimal padding). The length of the returned bytes by Bitwise.shift_right is max 0 (l - s / 8) bytes, where l is the length of the original bytes, and s is the natural number.