Overview

Package bits implements bit counting and manipulation functions for the
predeclared unsigned integer types.

Index

• func LeadingZeros(x uint) int
• func LeadingZeros32(x uint32) int
• func LeadingZeros8(x uint8) int
• func Len16(x uint16) (n int)
• func Len64(x uint64) (n int)
• func OnesCount(x uint) int
• func OnesCount32(x uint32) int
• func OnesCount8(x uint8) int
• func Reverse16(x uint16) uint16
• func Reverse64(x uint64) uint64
• func ReverseBytes(x uint) uint
• func ReverseBytes32(x uint32) uint32
• func RotateLeft(x uint, k int) uint
• func RotateLeft32(x uint32, k int) uint32
• func RotateLeft8(x uint8, k int) uint8
• func TrailingZeros16(x uint16) (n int)
• func TrailingZeros64(x uint64) int

• LeadingZeros16
• LeadingZeros64
• Len16
• Len64
• OnesCount16
• OnesCount64
• Reverse16
• Reverse64
• ReverseBytes16
• ReverseBytes64
• RotateLeft32
• RotateLeft8
• TrailingZeros32
• TrailingZeros8

Package files

bits.go

Constants

UintSize is the size of a uint in bits.

func LeadingZeros

func LeadingZeros(x uint) 

LeadingZeros returns the number of leading zero bits in x; the result is
UintSize for x == 0.

func LeadingZeros16

func LeadingZeros16(x uint16) 

LeadingZeros16 returns the number of leading zero bits in x; the result is 16
for x == 0.

Example:

// Output:
// LeadingZeros16(0000000000000001) = 15

func
¶

func LeadingZeros32(x ) int

LeadingZeros32 returns the number of leading zero bits in x; the result is 32
for x == 0.

Example:

fmt.Printf("LeadingZeros32(%032b) = %d\n", 1, bits.LeadingZeros32(1))
// Output:
// LeadingZeros32(00000000000000000000000000000001) = 31

func LeadingZeros64

func LeadingZeros64(x uint64) 

LeadingZeros64 returns the number of leading zero bits in x; the result is 64
for x == 0.

Example:

fmt.Printf("LeadingZeros64(%064b) = %d\n", 1, bits.LeadingZeros64(1))
// Output:
// LeadingZeros64(0000000000000000000000000000000000000000000000000000000000000001) = 63

func
¶

func LeadingZeros8(x ) int

LeadingZeros8 returns the number of leading zero bits in x; the result is 8 for
x == 0.

Example:

fmt.Printf("LeadingZeros8(%08b) = %d\n", 1, bits.LeadingZeros8(1))
// Output:
// LeadingZeros8(00000001) = 7

func Len

func Len(x uint) 

Len returns the minimum number of bits required to represent x; the result is 0
for x == 0.

func Len16

func Len16(x uint16) (n )

Len16 returns the minimum number of bits required to represent x; the result is
0 for x == 0.

Example:

fmt.Printf("Len16(%016b) = %d\n", 8, bits.Len16(8))
// Output:
// Len16(0000000000001000) = 4

func
¶

func Len32(x ) (n int)

Len32 returns the minimum number of bits required to represent x; the result is
0 for x == 0.

Example:

fmt.Printf("Len32(%032b) = %d\n", 8, bits.Len32(8))
// Output:
// Len32(00000000000000000000000000001000) = 4

func Len64(x uint64) (n )

Len64 returns the minimum number of bits required to represent x; the result is
0 for x == 0.

Example:

fmt.Printf("Len64(%064b) = %d\n", 8, bits.Len64(8))
// Output:
// Len64(0000000000000000000000000000000000000000000000000000000000001000) = 4

func
¶

func Len8(x ) int

Len8 returns the minimum number of bits required to represent x; the result is 0
for x == 0.

Example:

fmt.Printf("Len8(%08b) = %d\n", 8, bits.Len8(8))
// Output:
// Len8(00001000) = 4

func OnesCount

func OnesCount(x uint) 

OnesCount returns the number of one bits (“population count”) in x.

func OnesCount16

OnesCount16 returns the number of one bits (“population count”) in x.

Example:

fmt.Printf("OnesCount16(%016b) = %d\n", 14, bits.OnesCount16(14))
// Output:
// OnesCount16(0000000000001110) = 3

func
¶

func OnesCount32(x ) int

OnesCount32 returns the number of one bits (“population count”) in x.

Example:

fmt.Printf("OnesCount32(%032b) = %d\n", 14, bits.OnesCount32(14))
// Output:
// OnesCount32(00000000000000000000000000001110) = 3

func OnesCount64

func OnesCount64(x uint64) 

OnesCount64 returns the number of one bits (“population count”) in x.

Example:

fmt.Printf("OnesCount64(%064b) = %d\n", 14, bits.OnesCount64(14))
// Output:
// OnesCount64(0000000000000000000000000000000000000000000000000000000000001110) = 3

func
¶

func OnesCount8(x ) int

OnesCount8 returns the number of one bits (“population count”) in x.

Example:

fmt.Printf("OnesCount8(%08b) = %d\n", 14, bits.OnesCount8(14))
// Output:
// OnesCount8(00001110) = 3

func Reverse

func Reverse(x uint) 

Reverse returns the value of x with its bits in reversed order.

func Reverse16

func Reverse16(x uint16) 

Reverse16 returns the value of x with its bits in reversed order.

Example:

fmt.Printf("%016b\n", bits.Reverse16(19))
// Output:
// 0000000000010011
// 1100100000000000

func
¶

func Reverse32(x ) uint32

Reverse32 returns the value of x with its bits in reversed order.

Example:

fmt.Printf("%032b\n", 19)
fmt.Printf("%032b\n", bits.Reverse32(19))
// Output:
// 00000000000000000000000000010011
// 11001000000000000000000000000000

func Reverse64

func Reverse64(x uint64) 

Reverse64 returns the value of x with its bits in reversed order.

Example:

fmt.Printf("%064b\n", 19)
fmt.Printf("%064b\n", bits.Reverse64(19))
// Output:
// 0000000000000000000000000000000000000000000000000000000000010011
// 1100100000000000000000000000000000000000000000000000000000000000

func
¶

func Reverse8(x ) uint8

Reverse8 returns the value of x with its bits in reversed order.

Example:

fmt.Printf("%08b\n", 19)
// Output:
// 00010011
// 11001000

func ReverseBytes(x uint) 

ReverseBytes returns the value of x with its bytes in reversed order.

func ReverseBytes16

func ReverseBytes16(x uint16) 

ReverseBytes16 returns the value of x with its bytes in reversed order.

Example:

fmt.Printf("%016b\n", 15)
fmt.Printf("%016b\n", bits.ReverseBytes16(15))
// Output:
// 0000000000001111
// 0000111100000000

func
¶

ReverseBytes32 returns the value of x with its bytes in reversed order.

Example:

fmt.Printf("%032b\n", 15)
fmt.Printf("%032b\n", bits.ReverseBytes32(15))
// Output:
// 00000000000000000000000000001111
// 00001111000000000000000000000000

func ReverseBytes64

func ReverseBytes64(x uint64) 

ReverseBytes64 returns the value of x with its bytes in reversed order.

Example:

fmt.Printf("%064b\n", 15)
fmt.Printf("%064b\n", bits.ReverseBytes64(15))
// Output:
// 0000000000000000000000000000000000000000000000000000000000001111
// 0000111100000000000000000000000000000000000000000000000000000000

func
¶

func RotateLeft(x , k int) 

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

func RotateLeft16(x uint16, k ) 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:

fmt.Printf("%016b\n", 15)
fmt.Printf("%016b\n", bits.RotateLeft16(15, 2))
// Output:
// 0000000000001111
// 0000000000111100
// 1100000000000011

func RotateLeft32

func RotateLeft32(x uint32, k ) 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:

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

func RotateLeft64(x uint64, k ) 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:

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

func RotateLeft8(x uint8, k ) 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:

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

func TrailingZeros(x uint) 

TrailingZeros returns the number of trailing zero bits in x; the result is
UintSize for x == 0.

func TrailingZeros16

func TrailingZeros16(x uint16) (n )

TrailingZeros16 returns the number of trailing zero bits in x; the result is 16
for x == 0.

Example:

fmt.Printf("TrailingZeros16(%016b) = %d\n", 14, bits.TrailingZeros16(14))
// Output:
// TrailingZeros16(0000000000001110) = 1

func
¶

func TrailingZeros32(x ) int

TrailingZeros32 returns the number of trailing zero bits in x; the result is 32
for x == 0.

Example:

fmt.Printf("TrailingZeros32(%032b) = %d\n", 14, bits.TrailingZeros32(14))
// Output:
// TrailingZeros32(00000000000000000000000000001110) = 1

func TrailingZeros64(x uint64) 

TrailingZeros64 returns the number of trailing zero bits in x; the result is 64
for x == 0.

Example:

fmt.Printf("TrailingZeros64(%064b) = %d\n", 14, bits.TrailingZeros64(14))
// Output:
// TrailingZeros64(0000000000000000000000000000000000000000000000000000000000001110) = 1

func
¶

Example:

fmt.Printf("TrailingZeros8(%08b) = %d\n", 14, bits.TrailingZeros8(14))