import "math/bits"
Package bits implements bit counting and manipulation functions for the predeclared unsigned integer types.
const UintSize = uintSize
UintSize is the size of a uint in bits.
func Add(x, y, carry uint) (sum, carryOut uint)
Add returns the sum with carry of x, y and carry: sum = x + y + carry. The carry input must be 0 or 1; otherwise the behavior is undefined. The carryOut output is guaranteed to be 0 or 1.
This function's execution time does not depend on the inputs.
func Add32(x, y, carry uint32) (sum, carryOut uint32)
Add32 returns the sum with carry of x, y and carry: sum = x + y + carry. The carry input must be 0 or 1; otherwise the behavior is undefined. The carryOut output is guaranteed to be 0 or 1.
This function's execution time does not depend on the inputs.
func Add64(x, y, carry uint64) (sum, carryOut uint64)
Add64 returns the sum with carry of x, y and carry: sum = x + y + carry. The carry input must be 0 or 1; otherwise the behavior is undefined. The carryOut output is guaranteed to be 0 or 1.
This function's execution time does not depend on the inputs.
func Div(hi, lo, y uint) (quo, rem uint)
Div returns the quotient and remainder of (hi, lo) divided by y: quo = (hi, lo)/y, rem = (hi, lo)%y with the dividend bits' upper half in parameter hi and the lower half in parameter lo. Div panics for y == 0 (division by zero) or y <= hi (quotient overflow).
func Div32(hi, lo, y uint32) (quo, rem uint32)
Div32 returns the quotient and remainder of (hi, lo) divided by y: quo = (hi, lo)/y, rem = (hi, lo)%y with the dividend bits' upper half in parameter hi and the lower half in parameter lo. Div32 panics for y == 0 (division by zero) or y <= hi (quotient overflow).
func Div64(hi, lo, y uint64) (quo, rem uint64)
Div64 returns the quotient and remainder of (hi, lo) divided by y: quo = (hi, lo)/y, rem = (hi, lo)%y with the dividend bits' upper half in parameter hi and the lower half in parameter lo. Div64 panics for y == 0 (division by zero) or y <= hi (quotient overflow).
func LeadingZeros(x uint) int
LeadingZeros returns the number of leading zero bits in x; the result is UintSize for x == 0.
func LeadingZeros16(x uint16) int
LeadingZeros16 returns the number of leading zero bits in x; the result is 16 for x == 0.
Code:
fmt.Printf("LeadingZeros16(%016b) = %d\n", 1, bits.LeadingZeros16(1))
Output:
LeadingZeros16(0000000000000001) = 15
func LeadingZeros32(x uint32) int
LeadingZeros32 returns the number of leading zero bits in x; the result is 32 for x == 0.
Code:
fmt.Printf("LeadingZeros32(%032b) = %d\n", 1, bits.LeadingZeros32(1))
Output:
LeadingZeros32(00000000000000000000000000000001) = 31
func LeadingZeros64(x uint64) int
LeadingZeros64 returns the number of leading zero bits in x; the result is 64 for x == 0.
Code:
fmt.Printf("LeadingZeros64(%064b) = %d\n", 1, bits.LeadingZeros64(1))
Output:
LeadingZeros64(0000000000000000000000000000000000000000000000000000000000000001) = 63
func LeadingZeros8(x uint8) int
LeadingZeros8 returns the number of leading zero bits in x; the result is 8 for x == 0.
Code:
fmt.Printf("LeadingZeros8(%08b) = %d\n", 1, bits.LeadingZeros8(1))
Output:
LeadingZeros8(00000001) = 7
func Len(x uint) int
Len returns the minimum number of bits required to represent x; the result is 0 for x == 0.
func Len16(x uint16) (n int)
Len16 returns the minimum number of bits required to represent x; the result is 0 for x == 0.
Code:
fmt.Printf("Len16(%016b) = %d\n", 8, bits.Len16(8))
Output:
Len16(0000000000001000) = 4
func Len32(x uint32) (n int)
Len32 returns the minimum number of bits required to represent x; the result is 0 for x == 0.
Code:
fmt.Printf("Len32(%032b) = %d\n", 8, bits.Len32(8))
Output:
Len32(00000000000000000000000000001000) = 4
func Len64(x uint64) (n int)
Len64 returns the minimum number of bits required to represent x; the result is 0 for x == 0.
Code:
fmt.Printf("Len64(%064b) = %d\n", 8, bits.Len64(8))
Output:
Len64(0000000000000000000000000000000000000000000000000000000000001000) = 4
func Len8(x uint8) int
Len8 returns the minimum number of bits required to represent x; the result is 0 for x == 0.
Code:
fmt.Printf("Len8(%08b) = %d\n", 8, bits.Len8(8))
Output:
Len8(00001000) = 4
func Mul(x, y uint) (hi, lo uint)
Mul returns the full-width product of x and y: (hi, lo) = x * y with the product bits' upper half returned in hi and the lower half returned in lo.
This function's execution time does not depend on the inputs.
func Mul32(x, y uint32) (hi, lo uint32)
Mul32 returns the 64-bit product of x and y: (hi, lo) = x * y with the product bits' upper half returned in hi and the lower half returned in lo.
This function's execution time does not depend on the inputs.
func Mul64(x, y uint64) (hi, lo uint64)
Mul64 returns the 128-bit product of x and y: (hi, lo) = x * y with the product bits' upper half returned in hi and the lower half returned in lo.
This function's execution time does not depend on the inputs.
func OnesCount(x uint) int
OnesCount returns the number of one bits ("population count") in x.
Code:
fmt.Printf("OnesCount(%b) = %d\n", 14, bits.OnesCount(14))
Output:
OnesCount(1110) = 3
func OnesCount16(x uint16) int
OnesCount16 returns the number of one bits ("population count") in x.
Code:
fmt.Printf("OnesCount16(%016b) = %d\n", 14, bits.OnesCount16(14))
Output:
OnesCount16(0000000000001110) = 3
func OnesCount32(x uint32) int
OnesCount32 returns the number of one bits ("population count") in x.
Code:
fmt.Printf("OnesCount32(%032b) = %d\n", 14, bits.OnesCount32(14))
Output:
OnesCount32(00000000000000000000000000001110) = 3
func OnesCount64(x uint64) int
OnesCount64 returns the number of one bits ("population count") in x.
Code:
fmt.Printf("OnesCount64(%064b) = %d\n", 14, bits.OnesCount64(14))
Output:
OnesCount64(0000000000000000000000000000000000000000000000000000000000001110) = 3
func OnesCount8(x uint8) int
OnesCount8 returns the number of one bits ("population count") in x.
Code:
fmt.Printf("OnesCount8(%08b) = %d\n", 14, bits.OnesCount8(14))
Output:
OnesCount8(00001110) = 3
func Reverse(x uint) uint
Reverse returns the value of x with its bits in reversed order.
func Reverse16(x uint16) uint16
Reverse16 returns the value of x with its bits in reversed order.
Code:
fmt.Printf("%016b\n", 19)
fmt.Printf("%016b\n", bits.Reverse16(19))
Output:
0000000000010011 1100100000000000
func Reverse32(x uint32) uint32
Reverse32 returns the value of x with its bits in reversed order.
Code:
fmt.Printf("%032b\n", 19)
fmt.Printf("%032b\n", bits.Reverse32(19))
Output:
00000000000000000000000000010011 11001000000000000000000000000000
func Reverse64(x uint64) uint64
Reverse64 returns the value of x with its bits in reversed order.
Code:
fmt.Printf("%064b\n", 19)
fmt.Printf("%064b\n", bits.Reverse64(19))
Output:
0000000000000000000000000000000000000000000000000000000000010011 1100100000000000000000000000000000000000000000000000000000000000
func Reverse8(x uint8) uint8
Reverse8 returns the value of x with its bits in reversed order.
Code:
fmt.Printf("%08b\n", 19)
fmt.Printf("%08b\n", bits.Reverse8(19))
Output:
00010011 11001000
func ReverseBytes(x uint) uint
ReverseBytes returns the value of x with its bytes in reversed order.
This function's execution time does not depend on the inputs.
func ReverseBytes16(x uint16) uint16
ReverseBytes16 returns the value of x with its bytes in reversed order.
This function's execution time does not depend on the inputs.
Code:
fmt.Printf("%016b\n", 15)
fmt.Printf("%016b\n", bits.ReverseBytes16(15))
Output:
0000000000001111 0000111100000000
func ReverseBytes32(x uint32) uint32
ReverseBytes32 returns the value of x with its bytes in reversed order.
This function's execution time does not depend on the inputs.
Code:
fmt.Printf("%032b\n", 15)
fmt.Printf("%032b\n", bits.ReverseBytes32(15))
Output:
00000000000000000000000000001111 00001111000000000000000000000000
func ReverseBytes64(x uint64) uint64
ReverseBytes64 returns the value of x with its bytes in reversed order.
This function's execution time does not depend on the inputs.
Code:
fmt.Printf("%064b\n", 15)
fmt.Printf("%064b\n", bits.ReverseBytes64(15))
Output:
0000000000000000000000000000000000000000000000000000000000001111 0000111100000000000000000000000000000000000000000000000000000000
func RotateLeft(x uint, k int) uint
RotateLeft returns the value of x rotated left by (k mod UintSize) bits. To rotate x right by k bits, call RotateLeft(x, -k).
This function's execution time does not depend on the inputs.
func RotateLeft16(x uint16, k int) uint16
RotateLeft16 returns the value of x rotated left by (k mod 16) bits. To rotate x right by k bits, call RotateLeft16(x, -k).
This function's execution time does not depend on the inputs.
Code:
fmt.Printf("%016b\n", 15)
fmt.Printf("%016b\n", bits.RotateLeft16(15, 2))
fmt.Printf("%016b\n", bits.RotateLeft16(15, -2))
Output:
0000000000001111 0000000000111100 1100000000000011
func RotateLeft32(x uint32, k int) uint32
RotateLeft32 returns the value of x rotated left by (k mod 32) bits. To rotate x right by k bits, call RotateLeft32(x, -k).
This function's execution time does not depend on the inputs.
Code:
fmt.Printf("%032b\n", 15)
fmt.Printf("%032b\n", bits.RotateLeft32(15, 2))
fmt.Printf("%032b\n", bits.RotateLeft32(15, -2))
Output:
00000000000000000000000000001111 00000000000000000000000000111100 11000000000000000000000000000011
func RotateLeft64(x uint64, k int) uint64
RotateLeft64 returns the value of x rotated left by (k mod 64) bits. To rotate x right by k bits, call RotateLeft64(x, -k).
This function's execution time does not depend on the inputs.
Code:
fmt.Printf("%064b\n", 15)
fmt.Printf("%064b\n", bits.RotateLeft64(15, 2))
fmt.Printf("%064b\n", bits.RotateLeft64(15, -2))
Output:
0000000000000000000000000000000000000000000000000000000000001111 0000000000000000000000000000000000000000000000000000000000111100 1100000000000000000000000000000000000000000000000000000000000011
func RotateLeft8(x uint8, k int) uint8
RotateLeft8 returns the value of x rotated left by (k mod 8) bits. To rotate x right by k bits, call RotateLeft8(x, -k).
This function's execution time does not depend on the inputs.
Code:
fmt.Printf("%08b\n", 15)
fmt.Printf("%08b\n", bits.RotateLeft8(15, 2))
fmt.Printf("%08b\n", bits.RotateLeft8(15, -2))
Output:
00001111 00111100 11000011
func Sub(x, y, borrow uint) (diff, borrowOut uint)
Sub returns the difference of x, y and borrow: diff = x - y - borrow. The borrow input must be 0 or 1; otherwise the behavior is undefined. The borrowOut output is guaranteed to be 0 or 1.
This function's execution time does not depend on the inputs.
func Sub32(x, y, borrow uint32) (diff, borrowOut uint32)
Sub32 returns the difference of x, y and borrow, diff = x - y - borrow. The borrow input must be 0 or 1; otherwise the behavior is undefined. The borrowOut output is guaranteed to be 0 or 1.
This function's execution time does not depend on the inputs.
func Sub64(x, y, borrow uint64) (diff, borrowOut uint64)
Sub64 returns the difference of x, y and borrow: diff = x - y - borrow. The borrow input must be 0 or 1; otherwise the behavior is undefined. The borrowOut output is guaranteed to be 0 or 1.
This function's execution time does not depend on the inputs.
func TrailingZeros(x uint) int
TrailingZeros returns the number of trailing zero bits in x; the result is UintSize for x == 0.
func TrailingZeros16(x uint16) int
TrailingZeros16 returns the number of trailing zero bits in x; the result is 16 for x == 0.
Code:
fmt.Printf("TrailingZeros16(%016b) = %d\n", 14, bits.TrailingZeros16(14))
Output:
TrailingZeros16(0000000000001110) = 1
func TrailingZeros32(x uint32) int
TrailingZeros32 returns the number of trailing zero bits in x; the result is 32 for x == 0.
Code:
fmt.Printf("TrailingZeros32(%032b) = %d\n", 14, bits.TrailingZeros32(14))
Output:
TrailingZeros32(00000000000000000000000000001110) = 1
func TrailingZeros64(x uint64) int
TrailingZeros64 returns the number of trailing zero bits in x; the result is 64 for x == 0.
Code:
fmt.Printf("TrailingZeros64(%064b) = %d\n", 14, bits.TrailingZeros64(14))
Output:
TrailingZeros64(0000000000000000000000000000000000000000000000000000000000001110) = 1
func TrailingZeros8(x uint8) int
TrailingZeros8 returns the number of trailing zero bits in x; the result is 8 for x == 0.
Code:
fmt.Printf("TrailingZeros8(%08b) = %d\n", 14, bits.TrailingZeros8(14))
Output:
TrailingZeros8(00001110) = 1