Documentation
¶
Overview ¶
Package bits implements bit counting and manipulation functions for the predeclared unsigned integer types.
Index ¶
- Constants
- func LeadingZeros(x uint) int
- func LeadingZeros8(x uint8) int
- func LeadingZeros16(x uint16) int
- func LeadingZeros32(x uint32) int
- func LeadingZeros64(x uint64) int
- func Len(x uint) int
- func Len8(x uint8) int
- func Len16(x uint16) (n int)
- func Len32(x uint32) (n int)
- func Len64(x uint64) (n int)
- func OnesCount(x uint) int
- func OnesCount8(x uint8) int
- func OnesCount16(x uint16) int
- func OnesCount32(x uint32) int
- func OnesCount64(x uint64) int
- func Reverse(x uint) uint
- func Reverse8(x uint8) uint8
- func Reverse16(x uint16) uint16
- func Reverse32(x uint32) uint32
- func Reverse64(x uint64) uint64
- 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 RotateLeft8(x uint8, k int) uint8
- func RotateLeft16(x uint16, k int) uint16
- func RotateLeft32(x uint32, k int) uint32
- func RotateLeft64(x uint64, k int) uint64
- func TrailingZeros(x uint) int
- func TrailingZeros8(x uint8) int
- func TrailingZeros16(x uint16) (n int)
- func TrailingZeros32(x uint32) int
- func TrailingZeros64(x uint64) int
Examples ¶
- LeadingZeros8
- LeadingZeros16
- LeadingZeros32
- LeadingZeros64
- Len8
- Len16
- Len32
- Len64
- OnesCount8
- OnesCount16
- OnesCount32
- OnesCount64
- Reverse8
- Reverse16
- Reverse32
- Reverse64
- ReverseBytes16
- ReverseBytes32
- ReverseBytes64
- RotateLeft8
- RotateLeft16
- RotateLeft32
- RotateLeft64
- TrailingZeros8
- TrailingZeros16
- TrailingZeros32
- TrailingZeros64
Constants ¶
const UintSize = uintSize
UintSize is the size of a uint in bits.
Variables ¶
This section is empty.
Functions ¶
func LeadingZeros ¶
LeadingZeros returns the number of leading zero bits in x; the result is UintSize for x == 0.
func LeadingZeros8 ¶
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 LeadingZeros16 ¶
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 ¶
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 ¶
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 Len ¶
Len returns the minimum number of bits required to represent x; the result is 0 for x == 0.
func Len8 ¶
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 Len16 ¶
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 ¶
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 ¶
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 OnesCount8 ¶
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 OnesCount16 ¶
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 ¶
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 ¶
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 Reverse8 ¶
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 Reverse16 ¶
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 ¶
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 ¶
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 ReverseBytes ¶
ReverseBytes returns the value of x with its bytes in reversed order.