Package bits

import "math/bits"
Overview
Index
Examples
Documentation

Overview

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

Index

Constants
func LeadingZeros(x uint) int
func LeadingZeros16(x uint16) int
func LeadingZeros32(x uint32) int
func LeadingZeros64(x uint64) int
func LeadingZeros8(x uint8) int
func Len(x uint) int
func Len16(x uint16) (n int)
func Len32(x uint32) (n int)
func Len64(x uint64) (n int)
func Len8(x uint8) int
func OnesCount(x uint) int
func OnesCount16(x uint16) int
func OnesCount32(x uint32) int
func OnesCount64(x uint64) int
func OnesCount8(x uint8) int
func Reverse(x uint) uint
func Reverse16(x uint16) uint16
func Reverse32(x uint32) uint32
func Reverse64(x uint64) uint64
func Reverse8(x uint8) uint8
func ReverseBytes(x uint) uint
func ReverseBytes16(x uint16) uint16
func ReverseBytes32(x uint32) uint32
func ReverseBytes64(x uint64) uint64
func RotateLeft(x uint, k int) uint
func RotateLeft16(x uint16, k int) uint16
func RotateLeft32(x uint32, k int) uint32
func RotateLeft64(x uint64, k int) uint64
func RotateLeft8(x uint8, k int) uint8
func TrailingZeros(x uint) int
func TrailingZeros16(x uint16) (n int)
func TrailingZeros32(x uint32) int
func TrailingZeros64(x uint64) int
func TrailingZeros8(x uint8) int

Examples

LeadingZeros16
LeadingZeros32
LeadingZeros64
LeadingZeros8
Len16
Len32
Len64
Len8
OnesCount16
OnesCount32
OnesCount64
OnesCount8
Reverse16
Reverse32
Reverse64
Reverse8
ReverseBytes16
ReverseBytes32
ReverseBytes64
RotateLeft16
RotateLeft32
RotateLeft64
RotateLeft8
TrailingZeros16
TrailingZeros32
TrailingZeros64
TrailingZeros8

Documentation

Constants

const UintSize = uintSize

UintSize is the size of a uint in bits.

func LeadingZeros

func LeadingZeros(x uint) int

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

func LeadingZeros16

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

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

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

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

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

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

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

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

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 OnesCount

func OnesCount(x uint) int

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

func OnesCount16

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

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

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

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

func Reverse(x uint) uint

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

func Reverse16

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

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

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

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

func ReverseBytes(x uint) uint

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

func ReverseBytes16

func ReverseBytes16(x uint16) uint16

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

Code:

fmt.Printf("%016b\n", 15)
fmt.Printf("%016b\n", bits.ReverseBytes16(15))

Output:

0000000000001111
0000111100000000

func ReverseBytes32

func ReverseBytes32(x uint32) uint32

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

Code:

fmt.Printf("%032b\n", 15)
fmt.Printf("%032b\n", bits.ReverseBytes32(15))

Output:

00000000000000000000000000001111
00001111000000000000000000000000

func ReverseBytes64

func ReverseBytes64(x uint64) uint64

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

Code:

fmt.Printf("%064b\n", 15)
fmt.Printf("%064b\n", bits.ReverseBytes64(15))

Output:

0000000000000000000000000000000000000000000000000000000000001111
0000111100000000000000000000000000000000000000000000000000000000

func RotateLeft

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

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).

Code:

fmt.Printf("%016b\n", 15)
fmt.Printf("%016b\n", bits.RotateLeft16(15, 2))

Output:

0000000000001111
0000000000111100

func RotateLeft32

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).

Code:

fmt.Printf("%032b\n", 15)
fmt.Printf("%032b\n", bits.RotateLeft32(15, 2))

Output:

00000000000000000000000000001111
00000000000000000000000000111100

func RotateLeft64

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).

Code:

fmt.Printf("%064b\n", 15)
fmt.Printf("%064b\n", bits.RotateLeft64(15, 2))

Output:

0000000000000000000000000000000000000000000000000000000000001111
0000000000000000000000000000000000000000000000000000000000111100

func RotateLeft8

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).

Code:

fmt.Printf("%08b\n", 15)
fmt.Printf("%08b\n", bits.RotateLeft8(15, 2))

Output:

00001111
00111100

func TrailingZeros

func TrailingZeros(x uint) int

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

func TrailingZeros16

func TrailingZeros16(x uint16) (n 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

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

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

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