package bits

import "math/bits"

Package bits 实现了针对预声明无符号整数类型的位计数和位操作函数。

本包中的函数可能由编译器直接实现，以获得更好的性能。对于这些函数， 本包中的代码将不会被使用。哪些函数由编译器实现取决于架构和 Go 版本。

Index

Examples

Constants

const UintSize = uintSize

UintSize 是 uint 的大小（以位为单位）。

Functions

func Add

func Add(x, y, carry uint) (sum, carryOut uint)

Add 返回 x、y 与 carry 的带进位和：sum = x + y + carry。 carry 输入必须为 0 或 1；否则行为未定义。 carryOut 输出保证为 0 或 1。

此函数的执行时间不依赖于输入。

func Add32

func Add32(x, y, carry uint32) (sum, carryOut uint32)

Add32 返回 x、y 与 carry 的带进位和：sum = x + y + carry。 carry 输入必须为 0 或 1；否则行为未定义。 carryOut 输出保证为 0 或 1。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	// First number is 33<<32 + 12
	n1 := []uint32{33, 12}
	// Second number is 21<<32 + 23
	n2 := []uint32{21, 23}
	// Add them together without producing carry.
	d1, carry := bits.Add32(n1[1], n2[1], 0)
	d0, _ := bits.Add32(n1[0], n2[0], carry)
	nsum := []uint32{d0, d1}
	fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)

	// First number is 1<<32 + 2147483648
	n1 = []uint32{1, 0x80000000}
	// Second number is 1<<32 + 2147483648
	n2 = []uint32{1, 0x80000000}
	// Add them together producing carry.
	d1, carry = bits.Add32(n1[1], n2[1], 0)
	d0, _ = bits.Add32(n1[0], n2[0], carry)
	nsum = []uint32{d0, d1}
	fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
}

Output:

[33 12] + [21 23] = [54 35] (carry bit was 0)
[1 2147483648] + [1 2147483648] = [3 0] (carry bit was 1)

func Add64

func Add64(x, y, carry uint64) (sum, carryOut uint64)

Add64 返回 x、y 与 carry 的带进位和：sum = x + y + carry。 carry 输入必须为 0 或 1；否则行为未定义。 carryOut 输出保证为 0 或 1。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	// First number is 33<<64 + 12
	n1 := []uint64{33, 12}
	// Second number is 21<<64 + 23
	n2 := []uint64{21, 23}
	// Add them together without producing carry.
	d1, carry := bits.Add64(n1[1], n2[1], 0)
	d0, _ := bits.Add64(n1[0], n2[0], carry)
	nsum := []uint64{d0, d1}
	fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)

	// First number is 1<<64 + 9223372036854775808
	n1 = []uint64{1, 0x8000000000000000}
	// Second number is 1<<64 + 9223372036854775808
	n2 = []uint64{1, 0x8000000000000000}
	// Add them together producing carry.
	d1, carry = bits.Add64(n1[1], n2[1], 0)
	d0, _ = bits.Add64(n1[0], n2[0], carry)
	nsum = []uint64{d0, d1}
	fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
}

Output:

[33 12] + [21 23] = [54 35] (carry bit was 0)
[1 9223372036854775808] + [1 9223372036854775808] = [3 0] (carry bit was 1)

func Div

func Div(hi, lo, y uint) (quo, rem uint)

Div 返回 (hi, lo) 除以 y 的商和余数： quo = (hi, lo)/y，rem = (hi, lo)%y，其中被除数位的高半部分 位于参数 hi 中，低半部分位于参数 lo 中。 当 y == 0（除以零）或 y <= hi（商溢出）时，Div 会 panic。

func Div32

func Div32(hi, lo, y uint32) (quo, rem uint32)

Div32 返回 (hi, lo) 除以 y 的商和余数： quo = (hi, lo)/y，rem = (hi, lo)%y，其中被除数位的高半部分 位于参数 hi 中，低半部分位于参数 lo 中。 当 y == 0（除以零）或 y <= hi（商溢出）时，Div32 会 panic。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	// First number is 0<<32 + 6
	n1 := []uint32{0, 6}
	// Second number is 0<<32 + 3
	n2 := []uint32{0, 3}
	// Divide them together.
	quo, rem := bits.Div32(n1[0], n1[1], n2[1])
	nsum := []uint32{quo, rem}
	fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)

	// First number is 2<<32 + 2147483648
	n1 = []uint32{2, 0x80000000}
	// Second number is 0<<32 + 2147483648
	n2 = []uint32{0, 0x80000000}
	// Divide them together.
	quo, rem = bits.Div32(n1[0], n1[1], n2[1])
	nsum = []uint32{quo, rem}
	fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)
}

Output:

[0 6] / 3 = [2 0]
[2 2147483648] / 2147483648 = [5 0]

func Div64

func Div64(hi, lo, y uint64) (quo, rem uint64)

Div64 返回 (hi, lo) 除以 y 的商和余数： quo = (hi, lo)/y，rem = (hi, lo)%y，其中被除数位的高半部分 位于参数 hi 中，低半部分位于参数 lo 中。 当 y == 0（除以零）或 y <= hi（商溢出）时，Div64 会 panic。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	// First number is 0<<64 + 6
	n1 := []uint64{0, 6}
	// Second number is 0<<64 + 3
	n2 := []uint64{0, 3}
	// Divide them together.
	quo, rem := bits.Div64(n1[0], n1[1], n2[1])
	nsum := []uint64{quo, rem}
	fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)

	// First number is 2<<64 + 9223372036854775808
	n1 = []uint64{2, 0x8000000000000000}
	// Second number is 0<<64 + 9223372036854775808
	n2 = []uint64{0, 0x8000000000000000}
	// Divide them together.
	quo, rem = bits.Div64(n1[0], n1[1], n2[1])
	nsum = []uint64{quo, rem}
	fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)
}

Output:

[0 6] / 3 = [2 0]
[2 9223372036854775808] / 9223372036854775808 = [5 0]

func LeadingZeros

func LeadingZeros(x uint) int

LeadingZeros 返回 x 中前导零位的个数；当 x == 0 时结果为 UintSize。

func LeadingZeros16

func LeadingZeros16(x uint16) int

LeadingZeros16 返回 x 中前导零位的个数；当 x == 0 时结果为 16。

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 返回 x 中前导零位的个数；当 x == 0 时结果为 32。

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 返回 x 中前导零位的个数；当 x == 0 时结果为 64。

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 返回 x 中前导零位的个数；当 x == 0 时结果为 8。

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 返回表示 x 所需的最小位数；当 x == 0 时结果为 0。

func Len16

func Len16(x uint16) (n int)

Len16 返回表示 x 所需的最小位数；当 x == 0 时结果为 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 返回表示 x 所需的最小位数；当 x == 0 时结果为 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 返回表示 x 所需的最小位数；当 x == 0 时结果为 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 返回表示 x 所需的最小位数；当 x == 0 时结果为 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 Mul

func Mul(x, y uint) (hi, lo uint)

Mul 返回 x 与 y 的全宽乘积：(hi, lo) = x * y， 乘积位的高半部分在 hi 中返回，低半部分在 lo 中返回。

此函数的执行时间不依赖于输入。

func Mul32

func Mul32(x, y uint32) (hi, lo uint32)

Mul32 返回 x 与 y 的 64 位乘积：(hi, lo) = x * y， 乘积位的高半部分在 hi 中返回，低半部分在 lo 中返回。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	// First number is 0<<32 + 12
	n1 := []uint32{0, 12}
	// Second number is 0<<32 + 12
	n2 := []uint32{0, 12}
	// Multiply them together without producing overflow.
	hi, lo := bits.Mul32(n1[1], n2[1])
	nsum := []uint32{hi, lo}
	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)

	// First number is 0<<32 + 2147483648
	n1 = []uint32{0, 0x80000000}
	// Second number is 0<<32 + 2
	n2 = []uint32{0, 2}
	// Multiply them together producing overflow.
	hi, lo = bits.Mul32(n1[1], n2[1])
	nsum = []uint32{hi, lo}
	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)
}

Output:

12 * 12 = [0 144]
2147483648 * 2 = [1 0]

func Mul64

func Mul64(x, y uint64) (hi, lo uint64)

Mul64 返回 x 与 y 的 128 位乘积：(hi, lo) = x * y， 乘积位的高半部分在 hi 中返回，低半部分在 lo 中返回。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	// First number is 0<<64 + 12
	n1 := []uint64{0, 12}
	// Second number is 0<<64 + 12
	n2 := []uint64{0, 12}
	// Multiply them together without producing overflow.
	hi, lo := bits.Mul64(n1[1], n2[1])
	nsum := []uint64{hi, lo}
	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)

	// First number is 0<<64 + 9223372036854775808
	n1 = []uint64{0, 0x8000000000000000}
	// Second number is 0<<64 + 2
	n2 = []uint64{0, 2}
	// Multiply them together producing overflow.
	hi, lo = bits.Mul64(n1[1], n2[1])
	nsum = []uint64{hi, lo}
	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)
}

Output:

12 * 12 = [0 144]
9223372036854775808 * 2 = [1 0]

func OnesCount

func OnesCount(x uint) int

OnesCount 返回 x 中 1 位的个数（"population count"）。

Example 
package main

import (
	"fmt"
	"math/bits"
)

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

Output:

OnesCount(1110) = 3

func OnesCount16

func OnesCount16(x uint16) int

OnesCount16 返回 x 中 1 位的个数（"population count"）。

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 返回 x 中 1 位的个数（"population count"）。

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 返回 x 中 1 位的个数（"population count"）。

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 返回 x 中 1 位的个数（"population count"）。

Example 
package main

import (
	"fmt"
	"math/bits"
)

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

Output:

OnesCount8(00001110) = 3

func Rem

func Rem(hi, lo, y uint) uint

Rem 返回 (hi, lo) 除以 y 的余数。当 y == 0（除以零）时 Rem 会 panic， 但与 Div 不同，它在商溢出时不会 panic。

func Rem32

func Rem32(hi, lo, y uint32) uint32

Rem32 返回 (hi, lo) 除以 y 的余数。当 y == 0（除以零）时 Rem32 会 panic， 但与 Div32 不同，它在商溢出时不会 panic。

func Rem64

func Rem64(hi, lo, y uint64) uint64

Rem64 返回 (hi, lo) 除以 y 的余数。当 y == 0（除以零）时 Rem64 会 panic， 但与 Div64 不同，它在商溢出时不会 panic。

func Reverse

func Reverse(x uint) uint

Reverse 返回将 x 的位按相反顺序排列后的值。

func Reverse16

func Reverse16(x uint16) uint16

Reverse16 返回将 x 的位按相反顺序排列后的值。

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 返回将 x 的位按相反顺序排列后的值。

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 返回将 x 的位按相反顺序排列后的值。

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 返回将 x 的位按相反顺序排列后的值。

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 返回将 x 的字节按相反顺序排列后的值。

此函数的执行时间不依赖于输入。

func ReverseBytes16

func ReverseBytes16(x uint16) uint16

ReverseBytes16 返回将 x 的字节按相反顺序排列后的值。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	fmt.Printf("%016b\n", 15)
	fmt.Printf("%016b\n", bits.ReverseBytes16(15))
}

Output:

0000000000001111
0000111100000000

func ReverseBytes32

func ReverseBytes32(x uint32) uint32

ReverseBytes32 返回将 x 的字节按相反顺序排列后的值。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	fmt.Printf("%032b\n", 15)
	fmt.Printf("%032b\n", bits.ReverseBytes32(15))
}

Output:

00000000000000000000000000001111
00001111000000000000000000000000

func ReverseBytes64

func ReverseBytes64(x uint64) uint64

ReverseBytes64 返回将 x 的字节按相反顺序排列后的值。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	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 返回 x 循环左移 (k mod UintSize) 位后的值。 要将 x 循环右移 k 位，请调用 RotateLeft(x, -k)。

此函数的执行时间不依赖于输入。

func RotateLeft16

func RotateLeft16(x uint16, k int) uint16

RotateLeft16 返回 x 循环左移 (k mod 16) 位后的值。 要将 x 循环右移 k 位，请调用 RotateLeft16(x, -k)。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

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

func RotateLeft32(x uint32, k int) uint32

RotateLeft32 返回 x 循环左移 (k mod 32) 位后的值。 要将 x 循环右移 k 位，请调用 RotateLeft32(x, -k)。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

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

RotateLeft64 返回 x 循环左移 (k mod 64) 位后的值。 要将 x 循环右移 k 位，请调用 RotateLeft64(x, -k)。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

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

RotateLeft8 返回 x 循环左移 (k mod 8) 位后的值。 要将 x 循环右移 k 位，请调用 RotateLeft8(x, -k)。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

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

func Sub(x, y, borrow uint) (diff, borrowOut uint)

Sub 返回 x、y 与 borrow 的带借位差：diff = x - y - borrow。 borrow 输入必须为 0 或 1；否则行为未定义。 borrowOut 输出保证为 0 或 1。

此函数的执行时间不依赖于输入。

func Sub32

func Sub32(x, y, borrow uint32) (diff, borrowOut uint32)

Sub32 返回 x、y 与 borrow 的带借位差，diff = x - y - borrow。 borrow 输入必须为 0 或 1；否则行为未定义。 borrowOut 输出保证为 0 或 1。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	// First number is 33<<32 + 23
	n1 := []uint32{33, 23}
	// Second number is 21<<32 + 12
	n2 := []uint32{21, 12}
	// Sub them together without producing carry.
	d1, carry := bits.Sub32(n1[1], n2[1], 0)
	d0, _ := bits.Sub32(n1[0], n2[0], carry)
	nsum := []uint32{d0, d1}
	fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)

	// First number is 3<<32 + 2147483647
	n1 = []uint32{3, 0x7fffffff}
	// Second number is 1<<32 + 2147483648
	n2 = []uint32{1, 0x80000000}
	// Sub them together producing carry.
	d1, carry = bits.Sub32(n1[1], n2[1], 0)
	d0, _ = bits.Sub32(n1[0], n2[0], carry)
	nsum = []uint32{d0, d1}
	fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
}

Output:

[33 23] - [21 12] = [12 11] (carry bit was 0)
[3 2147483647] - [1 2147483648] = [1 4294967295] (carry bit was 1)

func Sub64

func Sub64(x, y, borrow uint64) (diff, borrowOut uint64)

Sub64 返回 x、y 与 borrow 的带借位差：diff = x - y - borrow。 borrow 输入必须为 0 或 1；否则行为未定义。 borrowOut 输出保证为 0 或 1。

此函数的执行时间不依赖于输入。

Example 
package main

import (
	"fmt"
	"math/bits"
)

func main() {
	// First number is 33<<64 + 23
	n1 := []uint64{33, 23}
	// Second number is 21<<64 + 12
	n2 := []uint64{21, 12}
	// Sub them together without producing carry.
	d1, carry := bits.Sub64(n1[1], n2[1], 0)
	d0, _ := bits.Sub64(n1[0], n2[0], carry)
	nsum := []uint64{d0, d1}
	fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)

	// First number is 3<<64 + 9223372036854775807
	n1 = []uint64{3, 0x7fffffffffffffff}
	// Second number is 1<<64 + 9223372036854775808
	n2 = []uint64{1, 0x8000000000000000}
	// Sub them together producing carry.
	d1, carry = bits.Sub64(n1[1], n2[1], 0)
	d0, _ = bits.Sub64(n1[0], n2[0], carry)
	nsum = []uint64{d0, d1}
	fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
}

Output:

[33 23] - [21 12] = [12 11] (carry bit was 0)
[3 9223372036854775807] - [1 9223372036854775808] = [1 18446744073709551615] (carry bit was 1)

func TrailingZeros

func TrailingZeros(x uint) int

TrailingZeros 返回 x 中末尾零位的个数；当 x == 0 时结果为 UintSize。

func TrailingZeros16

func TrailingZeros16(x uint16) int

TrailingZeros16 返回 x 中末尾零位的个数；当 x == 0 时结果为 16。

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 返回 x 中末尾零位的个数；当 x == 0 时结果为 32。

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 返回 x 中末尾零位的个数；当 x == 0 时结果为 64。

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 返回 x 中末尾零位的个数；当 x == 0 时结果为 8。

Example 
package main

import (
	"fmt"
	"math/bits"
)

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

Output:

TrailingZeros8(00001110) = 1