Пакет bits

• import "math/bits"
• Обзор
• Индекс
• Примеры

Обзор

Пакет bits реализует функции подсчёта и манипулирования битами для предопределённых типов беззнаковых целых чисел.

Функции в этом пакете могут быть реализованы непосредственно компилятором для лучшей производительности. Для таких функций код в этом пакете не будет использоваться. Какие функции реализуются компилятором зависит от архитектуры и версии Go.

Индекс

• Константы
• Функция Add(x, y, carry uint) (sum, carryOut uint)
• Функция Add32(x, y, carry uint32) (sum, carryOut uint32)
• Функция Add64(x, y, carry uint64) (sum, carryOut uint64)
• Функция Div(hi, lo, y uint) (quo, rem uint)
• Функция Div32(hi, lo, y uint32) (quo, rem uint32)
• Функция Div64(hi, lo, y uint64) (quo, rem uint64)
• Функция LeadingZeros(x uint) int
• Функция LeadingZeros16(x uint16) int
• Функция LeadingZeros32(x uint32) int
• Функция LeadingZeros64(x uint64) int
• Функция LeadingZeros8(x uint8) int
• Функция Len(x uint) int
• Функция Len16(x uint16) (n int)
• Функция Len32(x uint32) (n int)
• Функция Len64(x uint64) (n int)
• Функция Len8(x uint8) int
• Функция Mul(x, y uint) (hi, lo uint)
• Функция Mul32(x, y uint32) (hi, lo uint32)
• Функция Mul64(x, y uint64) (hi, lo uint64)
• Функция OnesCount(x uint) int
• Функция OnesCount16(x uint16) int
• Функция OnesCount32(x uint32) int
• Функция OnesCount64(x uint64) int
• Функция OnesCount8(x uint8) int
• Функция Rem(hi, lo, y uint) uint
• Функция Rem32(hi, lo, y uint32) uint32
• Функция Rem64(hi, lo, y uint64) uint64
• Функция Reverse(x uint) uint
• Функция Reverse16(x uint16) uint16
• Функция Reverse32(x uint32) uint32
• Функция Reverse64(x uint64) uint64
• Функция Reverse8(x uint8) uint8
• Функция ReverseBytes(x uint) uint
• Функция ReverseBytes16(x uint16) uint16
• Функция ReverseBytes32(x uint32) uint32
• Функция ReverseBytes64(x uint64) uint64
• Функция RotateLeft(x uint, k int) uint
• Функция RotateLeft16(x uint16, k int) uint16
• Функция RotateLeft32(x uint32, k int) uint32
• Функция RotateLeft64(x uint64, k int) uint64
• Функция RotateLeft8(x uint8, k int) uint8
• Функция Sub(x, y, borrow uint) (diff, borrowOut uint)
• Функция Sub32(x, y, borrow uint32) (diff, borrowOut uint32)
• Функция Sub64(x, y, borrow uint64) (diff, borrowOut uint64)
• Функция TrailingZeros(x uint) int
• Функция TrailingZeros16(x uint16) int
• Функция TrailingZeros32(x uint32) int
• Функция TrailingZeros64(x uint64) int
• Функция TrailingZeros8(x uint8) int

Файлы пакета

bits.go bits_errors.go bits_tables.go

Константы

UintSize — размер uint в битах.

const UintSize = uintSize

Функция Add 1.12

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

Add возвращает сумму с переносом x, y и carry: sum = x + y + carry. Входной carry должен быть 0 или 1; в противном случае поведение не определено. Выходной carryOut гарантированно будет 0 или 1.

Время выполнения этой функции не зависит от входных данных.

Функция Add32 1.12

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

Add32 возвращает сумму с переносом x, y и carry: 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)

Функция Add64 1.12

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

Add64 возвращает сумму с переносом x, y и carry: 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)

Функция 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 (переполнение частного).

Функция 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]

Функция 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]

Функция LeadingZeros 1.9

func LeadingZeros(x uint) int

LeadingZeros возвращает количество старших нулевых битов в x; результат равен UintSize для x == 0.

Функция LeadingZeros16 1.9

func LeadingZeros16(x uint16) int

LeadingZeros16 возвращает количество старших нулевых битов в x; результат равен 16 для x == 0.

Пример

Код:

fmt.Printf("LeadingZeros16(%016b) = %d\n", 1, bits.LeadingZeros16(1))

Вывод:

LeadingZeros16(0000000000000001) = 15

Функция LeadingZeros32 1.9

func LeadingZeros32(x uint32) int

LeadingZeros32 возвращает количество старших нулевых битов в x; результат равен 32 для x == 0.

Пример

Код:

fmt.Printf("LeadingZeros32(%032b) = %d\n", 1, bits.LeadingZeros32(1))

Вывод:

LeadingZeros32(00000000000000000000000000000001) = 31

Функция LeadingZeros64 1.9

func LeadingZeros64(x uint64) int

LeadingZeros64 возвращает количество старших нулевых битов в x; результат равен 64 для x == 0.

Пример

Код:

fmt.Printf("LeadingZeros64(%064b) = %d\n", 1, bits.LeadingZeros64(1))

Вывод:

LeadingZeros64(0000000000000000000000000000000000000000000000000000000000000001) = 63

Функция LeadingZeros8 1.9

func LeadingZeros8(x uint8) int

LeadingZeros8 возвращает количество старших нулевых битов в x; результат равен 8 для x == 0.

Пример

Код:

fmt.Printf("LeadingZeros8(%08b) = %d\n", 1, bits.LeadingZeros8(1))

Вывод:

LeadingZeros8(00000001) = 7

Функция Len 1.9

func Len(x uint) int

Len возвращает минимальное количество битов, необходимое для представления x; результат равен 0 для x == 0.

Функция Len16 1.9

func Len16(x uint16) (n int)

Len16 возвращает минимальное количество битов, необходимое для представления x; результат равен 0 для x == 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; результат равен 0 для x == 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; результат равен 0 для x == 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; результат равен 0 для x == 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. Входной заём должен быть равен 0 или 1; в противном случае поведение не определено. Выходной заём гарантированно равен 0 или 1.

Время выполнения этой функции не зависит от входных данных.

func Sub32 1.12

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

Sub32 возвращает разность x, y и заём, diff = x - y - borrow. Входной заём должен быть равен 0 или 1; в противном случае поведение не определено. Выходной заём гарантированно равен 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. Входной заём должен быть равен 0 или 1; в противном случае поведение не определено. Выходной заём гарантированно равен 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; результат равен UintSize для x == 0.

func TrailingZeros16 1.9

func TrailingZeros16(x uint16) int

TrailingZeros16 возвращает количество хвостовых нулевых битов в x; результат равен 16 для x == 0.

Пример

Код:

fmt.Printf("TrailingZeros16(%016b) = %d\n", 14, bits.TrailingZeros16(14))

Вывод:

TrailingZeros16(0000000000001110) = 1

func TrailingZeros32 1.9

func TrailingZeros32(x uint32) int

TrailingZeros32 возвращает количество нулевых битов в конце x; результат равен 32 для x == 0.

Пример

Код:

fmt.Printf("TrailingZeros32(%032b) = %d\n", 14, bits.TrailingZeros32(14))

Вывод:

TrailingZeros32(00000000000000000000000000001110) = 1

func TrailingZeros64 1.9

func TrailingZeros64(x uint64) int

TrailingZeros64 возвращает количество нулевых битов в конце x; результат равен 64 для x == 0.

Пример

Код:

fmt.Printf("TrailingZeros64(%064b) = %d\n", 14, bits.TrailingZeros64(14))

Вывод:

TrailingZeros64(0000000000000000000000000000000000000000000000000000000000001110) = 1

func TrailingZeros8 1.9

func TrailingZeros8(x uint8) int

TrailingZeros8 возвращает количество нулевых битов в конце x; результат равен 8 для x == 0.

Пример

Код:

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

Вывод:

TrailingZeros8(00001110) = 1