...

パッケージ bits

import "math/bits"
概要
目次

概要 ▾

bits パッケージは,符号なし整数型のビット計算関数,ビット操作関数を実装します。

目次 ▾

定数
func Add(x, y, carry uint) (sum, carryOut uint)
func Add32(x, y, carry uint32) (sum, carryOut uint32)
func Add64(x, y, carry uint64) (sum, carryOut uint64)
func Div(hi, lo, y uint) (quo, rem uint)
func Div32(hi, lo, y uint32) (quo, rem uint32)
func Div64(hi, lo, y uint64) (quo, rem uint64)
func LeadingZeros(x uint) int
func LeadingZeros16(x uint16) int
func LeadingZeros32(x uint32) int
func LeadingZeros64(x uint64) int
func LeadingZeros8(x uint8) int
func Len(x uint) int
func Len16(x uint16) (n int)
func Len32(x uint32) (n int)
func Len64(x uint64) (n int)
func Len8(x uint8) int
func Mul(x, y uint) (hi, lo uint)
func Mul32(x, y uint32) (hi, lo uint32)
func Mul64(x, y uint64) (hi, lo uint64)
func OnesCount(x uint) int
func OnesCount16(x uint16) int
func OnesCount32(x uint32) int
func OnesCount64(x uint64) int
func OnesCount8(x uint8) int
func Reverse(x uint) uint
func Reverse16(x uint16) uint16
func Reverse32(x uint32) uint32
func Reverse64(x uint64) uint64
func Reverse8(x uint8) uint8
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 RotateLeft16(x uint16, k int) uint16
func RotateLeft32(x uint32, k int) uint32
func RotateLeft64(x uint64, k int) uint64
func RotateLeft8(x uint8, k int) uint8
func Sub(x, y, borrow uint) (diff, borrowOut uint)
func Sub32(x, y, borrow uint32) (diff, borrowOut uint32)
func Sub64(x, y, borrow uint64) (diff, borrowOut uint64)
func TrailingZeros(x uint) int
func TrailingZeros16(x uint16) int
func TrailingZeros32(x uint32) int
func TrailingZeros64(x uint64) int
func TrailingZeros8(x uint8) int

パッケージファイル

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 と carry の合計を返します。 sum = x + y + carry 。 キャリー入力は 0 または 1 でなければなりません。 それ以外の場合の動作は未定義です。 carryOut 出力は 0 または 1 であることが保証されています。

この関数の実行時間は入力に依存しません。

func Add32 1.12

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

Add32 は, x, y ,および carry の合計を返します。 sum = x + y + carry 。 キャリー入力は 0 または 1 でなければなりません。 それ以外の場合の動作は未定義です。 carryOut 出力は 0 または 1 であることが保証されています。

この関数の実行時間は入力に依存しません。

func Add64 1.12

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

Add64 は, x, y ,および carry の合計を返します。 sum = x + y + carry 。 キャリー入力は 0 または 1 でなければなりません。 それ以外の場合の動作は未定義です。 carryOut 出力は 0 または 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 となります。 y == 0 (ゼロ除算) または y <= hi (商のオーバーフロー) の場合, div がパニックします。

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 (商のオーバーフロー) に対してパニックを起こします。

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 (商のオーバーフロー) の場合にパニックします。

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 は x と y の 64 ビットの積を返します。 (hi, lo) = x * y は積ビットの上半分が hi に,下半分が lo に返されます。

この関数の実行時間は入力に依存しません。

func Mul64 1.12

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

Mul64 は x と y の 128 ビットの積を返します。 (hi, lo) = x * y は積ビットの上半分が hi に,下半分が lo に返されます。

この関数の実行時間は入力に依存しません。

func OnesCount 1.9

func OnesCount(x uint) int

OnesCount は, x の 1 ビット数 ("population count") を返します。

コード:

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

出力:

OnesCount(1110) = 3

func OnesCount16 1.9

func OnesCount16(x uint16) int

OnesCount16 は, x の 1 ビット数 ("population count") を返します。

コード:

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

出力:

OnesCount16(0000000000001110) = 3

func OnesCount32 1.9

func OnesCount32(x uint32) int

OnesCount32 は, x の 1 ビット数 ("population count") を返します。

コード:

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

出力:

OnesCount32(00000000000000000000000000001110) = 3

func OnesCount64 1.9

func OnesCount64(x uint64) int

OnesCount64 は, x の 1 ビット数 ("population count") を返します。

コード:

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

出力:

OnesCount64(0000000000000000000000000000000000000000000000000000000000001110) = 3

func OnesCount8 1.9

func OnesCount8(x uint8) int

OnesCount8 は, x の 1 ビット数 ("population count") を返します。

コード:

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

出力:

OnesCount8(00001110) = 3

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 は, (k mod UintSize) ビットだけ左に回転した x の値を返します。 x を k ビットだけ右に回転するには, RotateLeft(x, -k) を呼び出します。

この関数の実行時間は入力に依存しません。

func RotateLeft16 1.9

func RotateLeft16(x uint16, k int) uint16

RotateLeft16 は, (k mod 16) ビットだけ左に回転した x の値を返します。 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 は, (k mod 32) ビットだけ左に回転した x の値を返します。 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 は, (k mod 64) ビットだけ左に回転した x の値を返します。 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 は, (k mod 8) ビットだけ左に回転した x の値を返します。 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 ,および borrow の差を返します。 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 ,および borrow の差を返します。 diff = x - y - borrow。 borrow 入力は 0 または 1 でなければなりません。 それ以外の場合の動作は未定義です。 borrowOut 出力は 0 または 1 であることが保証されています。

この関数の実行時間は入力に依存しません。

func Sub64 1.12

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

Sub64 は, x, y ,および borrow の差を返します。 diff = x - y - borrow 。 borrow 入力は 0 または 1 でなければなりません。 それ以外の場合の動作は未定義です。 borrowOut 出力は 0 または 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