Package bits
Package bits implements bit counting and manipulation
functions for the predeclared unsigned integer types.
In the call graph viewer below, each node
is a function belonging to this package
and its children are the functions it
calls—perhaps dynamically.
The root nodes are the entry points of the
package: functions that may be called from
outside the package.
There may be non-exported or anonymous
functions among them if they are called
dynamically from another package.
Click a node to visit that function's source code.
From there you can visit its callers by
clicking its declaring func
token.
Functions may be omitted if they were
determined to be unreachable in the
particular programs or tests that were
analyzed.
Constants
UintSize is the size of a uint in bits.
const UintSize = uintSize
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.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
Code:
fmt.Printf("Len8(%08b) = %d\n", 8, bits.Len8(8))
Output:
Len8(00001000) = 4
func OnesCount(x uint) int
OnesCount returns the number of one bits ("population count") in x.
func OnesCount16(x uint16) int
OnesCount16 returns the number of one bits ("population count") in x.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
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.
func ReverseBytes16(x uint16) uint16
ReverseBytes16 returns the value of x with its bytes in reversed order.
▾ Example
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.
▾ Example
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.
▾ Example
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).
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).
▾ Example
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).
▾ Example
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).
▾ Example
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).
▾ Example
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 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) (n int)
TrailingZeros16 returns the number of trailing zero bits in x; the result is 16 for x == 0.
▾ Example
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.
▾ Example
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.
▾ Example
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.
▾ Example
Code:
fmt.Printf("TrailingZeros8(%08b) = %d\n", 14, bits.TrailingZeros8(14))
Output:
TrailingZeros8(00001110) = 1