package core:math/bits

Source

The maximum value held by an i16. The same value as max(i16), except untyped.

The minimum value held by an i16. The same value as min(i16), except untyped.

The maximum value held by an i32. The same value as max(i32), except untyped.

The minimum value held by an i32. The same value as min(i32), except untyped.

The maximum value held by an i64. The same value as max(i64), except untyped.

The minimum value held by an i64. The same value as min(i64), except untyped.

The maximum value held by an i8. The same value as max(i8), except untyped.

The minimum value held by an i8. The same value as min(i8), except untyped.

The maximum value held by an int. The same value as max(int), except untyped.

The minimum value held by an int. The same value as min(int), except untyped.

The maximum value held by a u16. The same value as max(u16), except untyped.

The minimum value held by a u16. The same value as min(u16), except untyped.

The maximum value held by a u32. The same value as max(u32), except untyped.

The minimum value held by a u32. The same value as min(u32), except untyped.

The maximum value held by a u64. The same value as max(u64), except untyped.

The minimum value held by a u64. The same value as min(u64), except untyped.

The maximum value held by a u8. The same value as max(u8), except untyped.

The minimum value held by a u8. The same value as min(u8), except untyped.

The maximum value held by a uint. The same value as max(uint), except untyped.

The minimum value held by a uint. The same value as min(uint), except untyped.

Add with carry

Inputs:
x: The unsigned integer y: Another unsigned integer carry: Carry in

Returns:
sum: The sum carry_out: Carry out

• add

Add with carry

Inputs:
x: The unsigned integer y: Another unsigned integer carry: Carry in

Returns:
sum: The sum carry_out: Carry out

• add

Add with carry

Inputs:
x: The unsigned integer y: Another unsigned integer carry: Carry in

Returns:
sum: The sum carry_out: Carry out

• add

Extracts bits from a signed integer

Inputs:
value: Signed integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from a signed integer

Inputs:
value: Signed integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from a signed integer

Inputs:
value: Signed integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from a signed integer

Inputs:
value: Signed integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from a signed integer

Inputs:
value: Signed integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from a signed integer

Inputs:
value: Signed integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from an unsigned integer

Inputs:
value: Unsigned integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from an unsigned integer

Inputs:
value: Unsigned integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from an unsigned integer

Inputs:
value: Unsigned integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from an unsigned integer

Inputs:
value: Unsigned integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from an unsigned integer

Inputs:
value: Unsigned integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Extracts bits from an unsigned integer

Inputs:
value: Unsigned integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

• bitfield_extract

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

• bitfield_insert

Reverses the bytes from ascending order to descending order e.g. 0xfe_ed_01_12 -> 0x12_01_ed_fe

Counts the number of leading unset bits (0s) until a set bit (1) is seen or all bits have been counted.

Counts the number of set bits (1s).

Counts the number of trailing unset bits (0s) until a set bit (1) is seen or all bits have been counted.

Counts the number of unset bits (0s).

Divide a 64-bit unsigned integer (in two 32-bit words) by a 32-bit divisor

Inputs:
hi: High word of 64-bit integer lo: Low word of 64-bit integer y: Divisor

Returns:
quo: 32-bit quotient rem: 32-bit remainder

• div

Divide a 128-bit unsigned integer (in two 64-bit words) by a 64-bit divisor

Inputs:
hi: High word of 128-bit integer lo: Low word of 128-bit integer y: Divisor

Returns:
quo: 64-bit quotient rem: 64-bit Remainder

• div

Divide an unsigned integer (in two words) by a divisor

Inputs:
hi: High word of input lo: Low word of input y: Divisor

Returns:
quo: Quotient rem: Remainder

• div

Returns unsigned integer i, byte-swapped if we're on a little endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i, byte-swapped if we're on a little endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i, byte-swapped if we're on a little endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i

NOTE: A byte has no endianness, so from_be_u8 exists to be complementary to from_be_*.

Inputs:
i: The unsigned integer

Returns:
res: i

Returns unsigned integer i, byte-swapped if we're on a little endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i, byte-swapped if we're on a big endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i, byte-swapped if we're on a big endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i, byte-swapped if we're on a big endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i

NOTE: A byte has no endianness, so from_le_u8 exists to be complementary to from_le_*.

Inputs:
i: The unsigned integer

Returns:
res: i

Returns unsigned integer i, byte-swapped if we're on a big endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

• is_power_of_two

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

• is_power_of_two

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

• is_power_of_two

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

• is_power_of_two

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

• is_power_of_two

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

• is_power_of_two

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

• is_power_of_two

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

• is_power_of_two

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

• is_power_of_two

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

• is_power_of_two

Counts the number of leading unset bits (0s) until a set bit (1) is seen or all bits have been counted.

returns the minimum number of bits required to represent x

• len

returns the minimum number of bits required to represent x

• len

returns the minimum number of bits required to represent x

• len

returns the minimum number of bits required to represent x

• len

returns the minimum number of bits required to represent x

• len

Returns the base-2 logarithm of an unsigned integer x

Another way to say this is that log2(x) is the position of its leading 1 bit.

NOTE: This is ill-defined for 0 as it has no 1 bits, and log2(0) will return max(T).

Inputs:
x: The unsigned integer

Returns:
res: The base-2 logarithm of x

import "core:fmt"
import "core:math/bits"

log2_example :: proc() {
	for i in u8(1)..=8 {
		fmt.printfln("{0} ({0:4b}): {1}", i, bits.log2(i))
	}
	assert(bits.log2(  u8(0)) == max(u8))
	assert(bits.log2( u16(0)) == max(u16))
	assert(bits.log2( u32(0)) == max(u32))
	assert(bits.log2( u64(0)) == max(u64))
	assert(bits.log2(u128(0)) == max(u128))
}

1 (0001): 0
2 (0010): 1
3 (0011): 1
4 (0100): 2
5 (0101): 2
6 (0110): 2
7 (0111): 2
8 (1000): 3

Multiply two words and return the result in high and low word

Inputs:
x: The unsigned integer y: Another unsigned integer

Returns:
hi: The result's high word lo: The result's low word

• mul

Multiply two words and return the result in high and low word

Inputs:
x: The unsigned integer y: Another unsigned integer

Returns:
hi: The result's high word lo: The result's low word

• mul

Multiply two words and return the result in high and low word

Inputs:
x: The unsigned integer y: Another unsigned integer

Returns:
hi: The result's high word lo: The result's low word

• mul

Performs an "add" operation with an overflow check. The second return value will be true if an overflow occurs.

Performs a "multiply" operation with an overflow check. The second return value will be true if an overflow occurs.

Performs a "subtract" operation with an overflow check. The second return value will be true if an overflow occurs.

Reverses the bits from ascending order to descending order e.g. 0b01110101 -> 0b10101110

Returns unsigned integer x rotated left by k bits

Can be thought of as a bit shift in which the leading bits are shifted back in on the bottom, rather than dropped.

This is equivalent to the ROL CPU instruction.

Inputs:
x: The unsigned integer k: Number of bits to rotate left by

Returns:
res: x rotated left by k bits

Returns unsigned integer x rotated left by k bits

Can be thought of as a bit shift in which the leading bits are shifted back in on the bottom, rather than dropped.

This is equivalent to the ROL CPU instruction.

Inputs:
x: The unsigned integer k: Number of bits to rotate left by

Returns:
res: x rotated left by k bits

Returns unsigned integer x rotated left by k bits

Can be thought of as a bit shift in which the leading bits are shifted back in on the bottom, rather than dropped.

This is equivalent to the ROL CPU instruction.

Inputs:
x: The unsigned integer k: Number of bits to rotate left by

Returns:
res: x rotated left by k bits

Returns unsigned integer x rotated left by k bits

Can be thought of as a bit shift in which the leading bits are shifted back in on the bottom, rather than dropped.

This is equivalent to the ROL CPU instruction.

Inputs:
x: The unsigned integer k: Number of bits to rotate left by

Returns:
res: x rotated left by k bits

Returns unsigned integer x rotated left by k bits

Can be thought of as a bit shift in which the leading bits are shifted back in on the bottom, rather than dropped.

This is equivalent to the ROL CPU instruction.

Inputs:
x: The unsigned integer k: Number of bits to rotate left by

Returns:
res: x rotated left by k bits

import "core:fmt"
import "core:math/bits"

rotate_left8_example :: proc() {
	x := u8(13)
	for k in 0..<8 {
		fmt.printfln("{0:8b}: {1}", bits.rotate_left8(x, k), k)
	}
}

00001101: 0
00011010: 1
00110100: 2
01101000: 3
11010000: 4
10100001: 5
01000011: 6
10000110: 7

Subtract with borrow

Inputs:
x: The unsigned integer y: Another unsigned integer borrow: Borrow in

Returns:
diff: The difference borrow_out: Borrow out

• sub

Subtract with borrow

Inputs:
x: The unsigned integer y: Another unsigned integer borrow: Borrow in

Returns:
diff: The difference borrow_out: Borrow out

• sub

Subtract with borrow

Inputs:
x: The unsigned integer y: Another unsigned integer borrow: Borrow in

Returns:
diff: The difference borrow_out: Borrow out

• sub

Returns unsigned integer i, byte-swapped if we're on a little endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i, byte-swapped if we're on a little endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i, byte-swapped if we're on a little endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i

NOTE: A byte has no endianness, so to_be_u8 exists to be complementary to to_be_*.

Inputs:
i: The unsigned integer

Returns:
res: i

Returns unsigned integer i, byte-swapped if we're on a little endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i, byte-swapped if we're on a big endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i, byte-swapped if we're on a big endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i, byte-swapped if we're on a big endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Returns unsigned integer i

NOTE: A byte has no endianness, so to_le_u8 exists to be complementary to to_le_*.

Inputs:
i: The unsigned integer

Returns:
res: i

Returns unsigned integer i, byte-swapped if we're on a big endian target.

Inputs:
i: The unsigned integer

Returns:
res: i, optionally byte-swapped

Counts the number of trailing unset bits (0s) until a set bit (1) is seen or all bits have been counted.

Add with carry

Inputs:
x: The unsigned integer y: Another unsigned integer carry: Carry in

Returns:
sum: The sum carry_out: Carry out

Extracts bits from an integer

Inputs:
value: Integer offset: Offset (counting from LSB) at which to extract bits: Number of bits to extract

Returns:
res: bits bits starting at offset offset

Insert a subset of bits from one integer into another integer

Copies bits number of insert's lower bits to base at offset.

Inputs:
base: Original integer to insert bits into insert: Integer to copy bits from offset: Bit offset in base at which to place insert's bits bits: Number of bits to copy

Returns:
res: base with bits bits at offset replaced with insert's

Divide an unsigned integer (in two words) by a divisor

Inputs:
hi: High word of input lo: Low word of input y: Divisor

Returns:
quo: Quotient rem: Remainder

Checks whether an unsigned number is a power of two

Inputs:
i: Unsigned number

Returns:
is_pot: true if i is a power of two, false otherwise

returns the minimum number of bits required to represent x

Multiply two words and return the result in high and low word

Inputs:
x: The unsigned integer y: Another unsigned integer

Returns:
hi: The result's high word lo: The result's low word

Subtract with borrow

Inputs:
x: The unsigned integer y: Another unsigned integer borrow: Borrow in

Returns:
diff: The difference borrow_out: Borrow out