Пакет bits
Обзор
Пакет bits реализует функции подсчёта и обработки битов для предопределённых типов беззнаковых целых чисел.
Для повышения производительности функции этого пакета могут реализовываться непосредственно компилятором. Для таких функций код этого пакета использоваться не будет. Набор функций, реализуемых компилятором, зависит от архитектуры и версии Go.
Указатель
Примеры
- Add32
- Add64
- Div32
- Div64
- LeadingZeros16
- LeadingZeros32
- LeadingZeros64
- LeadingZeros8
- Len16
- Len32
- Len64
- Len8
- Mul32
- Mul64
- OnesCount
- OnesCount16
- OnesCount32
- OnesCount64
- OnesCount8
- Reverse16
- Reverse32
- Reverse64
- Reverse8
- ReverseBytes16
- ReverseBytes32
- ReverseBytes64
- RotateLeft16
- RotateLeft32
- RotateLeft64
- RotateLeft8
- Sub32
- Sub64
- TrailingZeros16
- TrailingZeros32
- TrailingZeros64
- TrailingZeros8
Файлы пакета
bits.go bits_errors.go bits_tables.go
Константы
UintSize — размер uint в битах.
const UintSize = uintSize
func Add 1.12
func Add(x, y, carry uint) (sum, carryOut uint)
Add возвращает сумму x, y и переноса: sum = x + y + carry. Входное значение carry должно быть равно 0 или 1; в противном случае поведение не определено. Выходное значение carryOut гарантированно равно 0 или 1.
Время выполнения этой функции не зависит от входных данных.
func Add32 1.12
func Add32(x, y, carry uint32) (sum, carryOut uint32)
Add32 возвращает сумму x, y и переноса: sum = x + y + carry. Входное значение carry должно быть равно 0 или 1; в противном случае поведение не определено. Выходное значение carryOut гарантированно равно 0 или 1.
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
// 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)
Вывод:
[33 12] + [21 23] = [54 35] (carry bit was 0) [1 2147483648] + [1 2147483648] = [3 0] (carry bit was 1)
func Add64 1.12
func Add64(x, y, carry uint64) (sum, carryOut uint64)
Add64 возвращает сумму x, y и переноса: sum = x + y + carry. Входное значение carry должно быть равно 0 или 1; в противном случае поведение не определено. Выходное значение carryOut гарантированно равно 0 или 1.
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
// 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)
Вывод:
[33 12] + [21 23] = [54 35] (carry bit was 0) [1 9223372036854775808] + [1 9223372036854775808] = [3 0] (carry bit was 1)
func Div 1.12
func Div(hi, lo, y uint) (quo, rem uint)
Div возвращает частное и остаток от деления (hi, lo) на y: quo = (hi, lo)/y, rem = (hi, lo)%y; старшая половина битов делимого передаётся в параметре hi, а младшая — в параметре lo. Div вызывает панику, если y == 0 (деление на ноль) или y <= hi (переполнение частного).
func Div32 1.12
func Div32(hi, lo, y uint32) (quo, rem uint32)
Div32 возвращает частное и остаток от деления (hi, lo) на y: quo = (hi, lo)/y, rem = (hi, lo)%y; старшая половина битов делимого передаётся в параметре hi, а младшая — в параметре lo. Div32 вызывает панику, если y == 0 (деление на ноль) или y <= hi (переполнение частного).
Пример
Код:
// 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)
Вывод:
[0 6] / 3 = [2 0] [2 2147483648] / 2147483648 = [5 0]
func Div64 1.12
func Div64(hi, lo, y uint64) (quo, rem uint64)
Div64 возвращает частное и остаток от деления (hi, lo) на y: quo = (hi, lo)/y, rem = (hi, lo)%y; старшая половина битов делимого передаётся в параметре hi, а младшая — в параметре lo. Div64 вызывает панику, если y == 0 (деление на ноль) или y <= hi (переполнение частного).
Пример
Код:
// 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)
Вывод:
[0 6] / 3 = [2 0] [2 9223372036854775808] / 9223372036854775808 = [5 0]
func LeadingZeros 1.9
func LeadingZeros(x uint) int
LeadingZeros возвращает количество ведущих нулевых битов в x; если x == 0, результат равен UintSize.
func LeadingZeros16 1.9
func LeadingZeros16(x uint16) int
LeadingZeros16 возвращает количество ведущих нулевых битов в x; если x == 0, результат равен 16.
Пример
Код:
fmt.Printf("LeadingZeros16(%016b) = %d\n", 1, bits.LeadingZeros16(1))
Вывод:
LeadingZeros16(0000000000000001) = 15
func LeadingZeros32 1.9
func LeadingZeros32(x uint32) int
LeadingZeros32 возвращает количество ведущих нулевых битов в x; если x == 0, результат равен 32.
Пример
Код:
fmt.Printf("LeadingZeros32(%032b) = %d\n", 1, bits.LeadingZeros32(1))
Вывод:
LeadingZeros32(00000000000000000000000000000001) = 31
func LeadingZeros64 1.9
func LeadingZeros64(x uint64) int
LeadingZeros64 возвращает количество ведущих нулевых битов в x; если x == 0, результат равен 64.
Пример
Код:
fmt.Printf("LeadingZeros64(%064b) = %d\n", 1, bits.LeadingZeros64(1))
Вывод:
LeadingZeros64(0000000000000000000000000000000000000000000000000000000000000001) = 63
func LeadingZeros8 1.9
func LeadingZeros8(x uint8) int
LeadingZeros8 возвращает количество ведущих нулевых битов в x; если x == 0, результат равен 8.
Пример
Код:
fmt.Printf("LeadingZeros8(%08b) = %d\n", 1, bits.LeadingZeros8(1))
Вывод:
LeadingZeros8(00000001) = 7
func Len 1.9
func Len(x uint) int
Len возвращает минимальное количество битов, необходимое для представления x; если x == 0, результат равен 0.
func Len16 1.9
func Len16(x uint16) (n int)
Len16 возвращает минимальное количество битов, необходимое для представления x; если x == 0, результат равен 0.
Пример
Код:
fmt.Printf("Len16(%016b) = %d\n", 8, bits.Len16(8))
Вывод:
Len16(0000000000001000) = 4
func Len32 1.9
func Len32(x uint32) (n int)
Len32 возвращает минимальное количество битов, необходимое для представления x; если x == 0, результат равен 0.
Пример
Код:
fmt.Printf("Len32(%032b) = %d\n", 8, bits.Len32(8))
Вывод:
Len32(00000000000000000000000000001000) = 4
func Len64 1.9
func Len64(x uint64) (n int)
Len64 возвращает минимальное количество битов, необходимое для представления x; если x == 0, результат равен 0.
Пример
Код:
fmt.Printf("Len64(%064b) = %d\n", 8, bits.Len64(8))
Вывод:
Len64(0000000000000000000000000000000000000000000000000000000000001000) = 4
func Len8 1.9
func Len8(x uint8) int
Len8 возвращает минимальное количество битов, необходимое для представления x; если x == 0, результат равен 0.
Пример
Код:
fmt.Printf("Len8(%08b) = %d\n", 8, bits.Len8(8))
Вывод:
Len8(00001000) = 4
func Mul 1.12
func Mul(x, y uint) (hi, lo uint)
Mul возвращает полное произведение x и y: (hi, lo) = x * y; старшая половина битов произведения возвращается в hi, младшая — в lo.
Время выполнения этой функции не зависит от входных данных.
func Mul32 1.12
func Mul32(x, y uint32) (hi, lo uint32)
Mul32 возвращает 64-битное произведение x и y: (hi, lo) = x * y; старшая половина битов произведения возвращается в hi, младшая — в lo.
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
// 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)
Вывод:
12 * 12 = [0 144] 2147483648 * 2 = [1 0]
func Mul64 1.12
func Mul64(x, y uint64) (hi, lo uint64)
Mul64 возвращает 128-битное произведение x и y: (hi, lo) = x * y; старшая половина битов произведения возвращается в hi, младшая — в lo.
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
// 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)
Вывод:
12 * 12 = [0 144] 9223372036854775808 * 2 = [1 0]
func OnesCount 1.9
func OnesCount(x uint) int
OnesCount возвращает количество единичных битов («вес Хэмминга») в x.
Пример
Код:
fmt.Printf("OnesCount(%b) = %d\n", 14, bits.OnesCount(14))
Вывод:
OnesCount(1110) = 3
func OnesCount16 1.9
func OnesCount16(x uint16) int
OnesCount16 возвращает количество единичных битов («вес Хэмминга») в x.
Пример
Код:
fmt.Printf("OnesCount16(%016b) = %d\n", 14, bits.OnesCount16(14))
Вывод:
OnesCount16(0000000000001110) = 3
func OnesCount32 1.9
func OnesCount32(x uint32) int
OnesCount32 возвращает количество единичных битов («вес Хэмминга») в x.
Пример
Код:
fmt.Printf("OnesCount32(%032b) = %d\n", 14, bits.OnesCount32(14))
Вывод:
OnesCount32(00000000000000000000000000001110) = 3
func OnesCount64 1.9
func OnesCount64(x uint64) int
OnesCount64 возвращает количество единичных битов («вес Хэмминга») в x.
Пример
Код:
fmt.Printf("OnesCount64(%064b) = %d\n", 14, bits.OnesCount64(14))
Вывод:
OnesCount64(0000000000000000000000000000000000000000000000000000000000001110) = 3
func OnesCount8 1.9
func OnesCount8(x uint8) int
OnesCount8 возвращает количество единичных битов («вес Хэмминга») в x.
Пример
Код:
fmt.Printf("OnesCount8(%08b) = %d\n", 14, bits.OnesCount8(14))
Вывод:
OnesCount8(00001110) = 3
func Rem 1.14
func Rem(hi, lo, y uint) uint
Rem возвращает остаток от деления (hi, lo) на y. Rem вызывает панику, если y == 0 (деление на ноль), но, в отличие от Div, не вызывает панику при переполнении частного.
func Rem32 1.14
func Rem32(hi, lo, y uint32) uint32
Rem32 возвращает остаток от деления (hi, lo) на y. Rem32 вызывает панику, если y == 0 (деление на ноль), но, в отличие от Div32, не вызывает панику при переполнении частного.
func Rem64 1.14
func Rem64(hi, lo, y uint64) uint64
Rem64 возвращает остаток от деления (hi, lo) на y. Rem64 вызывает панику, если y == 0 (деление на ноль), но, в отличие от Div64, не вызывает панику при переполнении частного.
func Reverse 1.9
func Reverse(x uint) uint
Reverse возвращает значение x с битами, расположенными в обратном порядке.
func Reverse16 1.9
func Reverse16(x uint16) uint16
Reverse16 возвращает значение x с битами, расположенными в обратном порядке.
Пример
Код:
fmt.Printf("%016b\n", 19)
fmt.Printf("%016b\n", bits.Reverse16(19))
Вывод:
0000000000010011 1100100000000000
func Reverse32 1.9
func Reverse32(x uint32) uint32
Reverse32 возвращает значение x с битами, расположенными в обратном порядке.
Пример
Код:
fmt.Printf("%032b\n", 19)
fmt.Printf("%032b\n", bits.Reverse32(19))
Вывод:
00000000000000000000000000010011 11001000000000000000000000000000
func Reverse64 1.9
func Reverse64(x uint64) uint64
Reverse64 возвращает значение x с битами, расположенными в обратном порядке.
Пример
Код:
fmt.Printf("%064b\n", 19)
fmt.Printf("%064b\n", bits.Reverse64(19))
Вывод:
0000000000000000000000000000000000000000000000000000000000010011 1100100000000000000000000000000000000000000000000000000000000000
func Reverse8 1.9
func Reverse8(x uint8) uint8
Reverse8 возвращает значение x с битами, расположенными в обратном порядке.
Пример
Код:
fmt.Printf("%08b\n", 19)
fmt.Printf("%08b\n", bits.Reverse8(19))
Вывод:
00010011 11001000
func ReverseBytes 1.9
func ReverseBytes(x uint) uint
ReverseBytes возвращает значение x с байтами, расположенными в обратном порядке.
Время выполнения этой функции не зависит от входных данных.
func ReverseBytes16 1.9
func ReverseBytes16(x uint16) uint16
ReverseBytes16 возвращает значение x с байтами, расположенными в обратном порядке.
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
fmt.Printf("%016b\n", 15)
fmt.Printf("%016b\n", bits.ReverseBytes16(15))
Вывод:
0000000000001111 0000111100000000
func ReverseBytes32 1.9
func ReverseBytes32(x uint32) uint32
ReverseBytes32 возвращает значение x с байтами, расположенными в обратном порядке.
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
fmt.Printf("%032b\n", 15)
fmt.Printf("%032b\n", bits.ReverseBytes32(15))
Вывод:
00000000000000000000000000001111 00001111000000000000000000000000
func ReverseBytes64 1.9
func ReverseBytes64(x uint64) uint64
ReverseBytes64 возвращает значение x с байтами, расположенными в обратном порядке.
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
fmt.Printf("%064b\n", 15)
fmt.Printf("%064b\n", bits.ReverseBytes64(15))
Вывод:
0000000000000000000000000000000000000000000000000000000000001111 0000111100000000000000000000000000000000000000000000000000000000
func RotateLeft 1.9
func RotateLeft(x uint, k int) uint
RotateLeft возвращает значение x, циклически сдвинутое влево на (k mod UintSize) битов. Чтобы циклически сдвинуть x вправо на k битов, вызовите RotateLeft(x, -k).
Время выполнения этой функции не зависит от входных данных.
func RotateLeft16 1.9
func RotateLeft16(x uint16, k int) uint16
RotateLeft16 возвращает значение x, циклически сдвинутое влево на (k mod 16) битов. Чтобы циклически сдвинуть x вправо на k битов, вызовите RotateLeft16(x, -k).
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
fmt.Printf("%016b\n", 15)
fmt.Printf("%016b\n", bits.RotateLeft16(15, 2))
fmt.Printf("%016b\n", bits.RotateLeft16(15, -2))
Вывод:
0000000000001111 0000000000111100 1100000000000011
func RotateLeft32 1.9
func RotateLeft32(x uint32, k int) uint32
RotateLeft32 возвращает значение x, циклически сдвинутое влево на (k mod 32) битов. Чтобы циклически сдвинуть x вправо на k битов, вызовите RotateLeft32(x, -k).
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
fmt.Printf("%032b\n", 15)
fmt.Printf("%032b\n", bits.RotateLeft32(15, 2))
fmt.Printf("%032b\n", bits.RotateLeft32(15, -2))
Вывод:
00000000000000000000000000001111 00000000000000000000000000111100 11000000000000000000000000000011
func RotateLeft64 1.9
func RotateLeft64(x uint64, k int) uint64
RotateLeft64 возвращает значение x, циклически сдвинутое влево на (k mod 64) битов. Чтобы циклически сдвинуть x вправо на k битов, вызовите RotateLeft64(x, -k).
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
fmt.Printf("%064b\n", 15)
fmt.Printf("%064b\n", bits.RotateLeft64(15, 2))
fmt.Printf("%064b\n", bits.RotateLeft64(15, -2))
Вывод:
0000000000000000000000000000000000000000000000000000000000001111 0000000000000000000000000000000000000000000000000000000000111100 1100000000000000000000000000000000000000000000000000000000000011
func RotateLeft8 1.9
func RotateLeft8(x uint8, k int) uint8
RotateLeft8 возвращает значение x, циклически сдвинутое влево на (k mod 8) битов. Чтобы циклически сдвинуть x вправо на k битов, вызовите RotateLeft8(x, -k).
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
fmt.Printf("%08b\n", 15)
fmt.Printf("%08b\n", bits.RotateLeft8(15, 2))
fmt.Printf("%08b\n", bits.RotateLeft8(15, -2))
Вывод:
00001111 00111100 11000011
func Sub 1.12
func Sub(x, y, borrow uint) (diff, borrowOut uint)
Sub возвращает разность x, y и займа: diff = x - y - borrow. Входное значение borrow должно быть равно 0 или 1; в противном случае поведение не определено. Выходное значение borrowOut гарантированно равно 0 или 1.
Время выполнения этой функции не зависит от входных данных.
func Sub32 1.12
func Sub32(x, y, borrow uint32) (diff, borrowOut uint32)
Sub32 возвращает разность x, y и займа: diff = x - y - borrow. Входное значение borrow должно быть равно 0 или 1; в противном случае поведение не определено. Выходное значение borrowOut гарантированно равно 0 или 1.
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
// 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)
Вывод:
[33 23] - [21 12] = [12 11] (carry bit was 0) [3 2147483647] - [1 2147483648] = [1 4294967295] (carry bit was 1)
func Sub64 1.12
func Sub64(x, y, borrow uint64) (diff, borrowOut uint64)
Sub64 возвращает разность x, y и займа: diff = x - y - borrow. Входное значение borrow должно быть равно 0 или 1; в противном случае поведение не определено. Выходное значение borrowOut гарантированно равно 0 или 1.
Время выполнения этой функции не зависит от входных данных.
Пример
Код:
// 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)
Вывод:
[33 23] - [21 12] = [12 11] (carry bit was 0) [3 9223372036854775807] - [1 9223372036854775808] = [1 18446744073709551615] (carry bit was 1)
func TrailingZeros 1.9
func TrailingZeros(x uint) int
TrailingZeros возвращает количество завершающих нулевых битов в x; если x == 0, результат равен UintSize.
func TrailingZeros16 1.9
func TrailingZeros16(x uint16) int
TrailingZeros16 возвращает количество завершающих нулевых битов в x; если x == 0, результат равен 16.
Пример
Код:
fmt.Printf("TrailingZeros16(%016b) = %d\n", 14, bits.TrailingZeros16(14))
Вывод:
TrailingZeros16(0000000000001110) = 1
func TrailingZeros32 1.9
func TrailingZeros32(x uint32) int
TrailingZeros32 возвращает количество завершающих нулевых битов в x; если x == 0, результат равен 32.
Пример
Код:
fmt.Printf("TrailingZeros32(%032b) = %d\n", 14, bits.TrailingZeros32(14))
Вывод:
TrailingZeros32(00000000000000000000000000001110) = 1
func TrailingZeros64 1.9
func TrailingZeros64(x uint64) int
TrailingZeros64 возвращает количество завершающих нулевых битов в x; если x == 0, результат равен 64.
Пример
Код:
fmt.Printf("TrailingZeros64(%064b) = %d\n", 14, bits.TrailingZeros64(14))
Вывод:
TrailingZeros64(0000000000000000000000000000000000000000000000000000000000001110) = 1
func TrailingZeros8 1.9
func TrailingZeros8(x uint8) int
TrailingZeros8 возвращает количество завершающих нулевых битов в x; если x == 0, результат равен 8.
Пример
Код:
fmt.Printf("TrailingZeros8(%08b) = %d\n", 14, bits.TrailingZeros8(14))
Вывод:
TrailingZeros8(00001110) = 1
© Google, Inc.
Licensed under the Creative Commons Attribution License 3.0.
http://golang.org/pkg/math/bits/
