bits

package
v0.0.0-...-9735fcf Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 2, 2017 License: BSD-3-Clause Imports: 0 Imported by: 0

Documentation

Overview

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

Index

Examples

Constants

View Source 
const UintSize = uintSize

UintSize is the size of a uint in bits.

Variables

This section is empty.

Functions

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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

func ReverseBytes32 

func ReverseBytes32(x uint32) uint32

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

func ReverseBytes64 

func ReverseBytes64(x uint64) uint64

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

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

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

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

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

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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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.

Example 
package main

import (
	"fmt"
	"math/bits"
)

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

Output:

TrailingZeros8(00001110) = 1

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.