bits

package

v1.23.0 Latest Latest Go to latest Published: Aug 14, 2024 License: MIT Imports: 0 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/shogo82148/std

Links

Open Source Insights

Documentation ¶

Overview ¶

bitsパッケージは、事前に宣言された符号なし整数型のためのビットカウントと操作関数を実装します。

このパッケージの関数は、パフォーマンス向上のためにコンパイラによって直接実装される可能性があります。そのような関数の場合、このパッケージのコードは使用されません。どの関数がコンパイラによって実装されるかは、アーキテクチャとGoのリリースによります。

Index ¶

Constants
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 Rem(hi, lo, y uint) uint
func Rem32(hi, lo, y uint32) uint32
func Rem64(hi, lo, y uint64) uint64
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

Constants ¶

View Source

const UintSize = uintSize

UintSizeは、uintのビット単位のサイズです。

Variables ¶

This section is empty.

Functions ¶

func Add ¶ added in v1.12.0

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 ¶ added in v1.12.0

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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

func main() {
	// 最初の数は 33<<32 + 12
	n1 := []uint32{33, 12}
	// 2番目の数は 21<<32 + 23
	n2 := []uint32{21, 23}
	// それらをキャリーを生成せずに合計します。
	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)

	// 最初の数は 1<<32 + 2147483648
	n1 = []uint32{1, 0x80000000}
	// 2番目の数は 1<<32 + 2147483648
	n2 = []uint32{1, 0x80000000}
	// それらを合計してキャリーを生成します。
	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 ¶ added in v1.12.0

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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

func main() {
	// 最初の数は 33<<64 + 12
	n1 := []uint64{33, 12}
	// 2番目の数は 21<<64 + 23
	n2 := []uint64{21, 23}
	// それらをキャリーを生成せずに合計します。
	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)

	// 最初の数は 1<<64 + 9223372036854775808
	n1 = []uint64{1, 0x8000000000000000}
	// 2番目の数は 1<<64 + 9223372036854775808
	n2 = []uint64{1, 0x8000000000000000}
	// それらを合計してキャリーを生成します。
	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 ¶ added in v1.12.0

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 ¶ added in v1.12.0

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はパニックします。

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

func main() {
	// 最初の数は 0<<32 + 6
	n1 := []uint32{0, 6}
	// 2番目の数は 0<<32 + 3
	n2 := []uint32{0, 3}
	// それらを割ります。
	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)

	// 最初の数は 2<<32 + 2147483648
	n1 = []uint32{2, 0x80000000}
	// 2番目の数は 0<<32 + 2147483648
	n2 = []uint32{0, 0x80000000}
	// それらを割ります。
	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 ¶ added in v1.12.0

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はパニックします。

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

func main() {
	// 最初の数は 0<<64 + 6
	n1 := []uint64{0, 6}
	// 2番目の数は 0<<64 + 3
	n2 := []uint64{0, 3}
	// それらを割ります。
	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)

	// 最初の数は 2<<64 + 9223372036854775808
	n1 = []uint64{2, 0x8000000000000000}
	// 2番目の数は 0<<64 + 9223372036854775808
	n2 = []uint64{0, 0x8000000000000000}
	// それらを割ります。
	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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

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

Output:

Len8(00001000) = 4

func Mul ¶ added in v1.12.0

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

Mulは、xとyの全幅の積を返します：(hi, lo) = x * y 積のビットの上半分はhiに、下半分はloに返されます。

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

func Mul32 ¶ added in v1.12.0

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

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

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

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

func main() {
	// 最初の数は 0<<32 + 12
	n1 := []uint32{0, 12}
	// 2番目の数は 0<<32 + 12
	n2 := []uint32{0, 12}
	// オーバーフローを生成せずにそれらを掛け合わせます。
	hi, lo := bits.Mul32(n1[1], n2[1])
	nsum := []uint32{hi, lo}
	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)

	// 最初の数は 0<<32 + 2147483648
	n1 = []uint32{0, 0x80000000}
	// 2番目の数は 0<<32 + 2
	n2 = []uint32{0, 2}
	// オーバーフローを生成するようにそれらを掛け合わせます。
	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 ¶ added in v1.12.0

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

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

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

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

func main() {
	// 最初の数は 0<<64 + 12
	n1 := []uint64{0, 12}
	// 2番目の数は 0<<64 + 12
	n2 := []uint64{0, 12}
	// オーバーフローを生成せずにそれらを掛け合わせます。
	hi, lo := bits.Mul64(n1[1], n2[1])
	nsum := []uint64{hi, lo}
	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)

	// 最初の数は 0<<64 + 9223372036854775808
	n1 = []uint64{0, 0x8000000000000000}
	// 2番目の数は 0<<64 + 2
	n2 = []uint64{0, 2}
	// オーバーフローを生成するようにそれらを掛け合わせます。
	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ビットの数（"ポピュレーションカウント"）を返します。

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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ビットの数（"ポピュレーションカウント"）を返します。

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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ビットの数（"ポピュレーションカウント"）を返します。

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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ビットの数（"ポピュレーションカウント"）を返します。

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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ビットの数（"ポピュレーションカウント"）を返します。

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

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

Output:

OnesCount8(00001110) = 3

func Rem ¶ added in v1.14.0

func Rem(hi, lo, y uint) uint

Remは、(hi, lo)をyで割った余りを返します。Remは y == 0の場合（ゼロ除算）にパニックしますが、Divとは異なり、商のオーバーフローではパニックしません。

func Rem32 ¶ added in v1.14.0

func Rem32(hi, lo, y uint32) uint32

Rem32は、(hi, lo)をyで割った余りを返します。Rem32は y == 0の場合（ゼロ除算）にパニックしますが、Div32 とは異なり、商のオーバーフローではパニックしません。

func Rem64 ¶ added in v1.14.0

func Rem64(hi, lo, y uint64) uint64

Rem64は、(hi, lo)をyで割った余りを返します。Rem64は y == 0の場合（ゼロ除算）にパニックしますが、Div64 とは異なり、商のオーバーフローではパニックしません。

func Reverse ¶

func Reverse(x uint) uint

Reverseは、ビットが逆順になったxの値を返します。

func Reverse16 ¶

func Reverse16(x uint16) uint16

Reverse16は、ビットが逆順になったxの値を返します。

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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))
}

func Sub ¶ added in v1.12.0

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 ¶ added in v1.12.0

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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

func main() {
	// 最初の数は 33<<32 + 23
	n1 := []uint32{33, 23}
	// 2番目の数は 21<<32 + 12
	n2 := []uint32{21, 12}
	// キャリーを生成せずにそれらを減算します。
	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)

	// 最初の数は 3<<32 + 2147483647
	n1 = []uint32{3, 0x7fffffff}
	// 2番目の数は 1<<32 + 2147483648
	n2 = []uint32{1, 0x80000000}
	// キャリーを生成してそれらを減算します。
	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 ¶ added in v1.12.0

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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

func main() {
	// 最初の数は 33<<64 + 23
	n1 := []uint64{33, 23}
	// 2番目の数は 21<<64 + 12
	n2 := []uint64{21, 12}
	// キャリーを生成せずにそれらを減算します。
	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)

	// 最初の数は 3<<64 + 9223372036854775807
	n1 = []uint64{3, 0x7fffffffffffffff}
	// 2番目の数は 1<<64 + 9223372036854775808
	n2 = []uint64{1, 0x8000000000000000}
	// キャリーを生成してそれらを減算します。
	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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math/bits"
)

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

Output:

TrailingZeros8(00001110) = 1

Types ¶

This section is empty.

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

Documentation ¶

Overview ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

func Add ¶ added in v1.12.0

func Add32 ¶ added in v1.12.0

func Add64 ¶ added in v1.12.0

func Div ¶ added in v1.12.0

func Div32 ¶ added in v1.12.0

func Div64 ¶ added in v1.12.0

func LeadingZeros ¶

func LeadingZeros16 ¶

func LeadingZeros32 ¶

func LeadingZeros64 ¶

func LeadingZeros8 ¶

func Len ¶

func Len16 ¶

func Len32 ¶

func Len64 ¶

func Len8 ¶

func Mul ¶ added in v1.12.0

func Mul32 ¶ added in v1.12.0

func Mul64 ¶ added in v1.12.0

func OnesCount ¶

func OnesCount16 ¶

func OnesCount32 ¶

func OnesCount64 ¶

func OnesCount8 ¶

func Rem ¶ added in v1.14.0

func Rem32 ¶ added in v1.14.0

func Rem64 ¶ added in v1.14.0

func Reverse ¶

func Reverse16 ¶

func Reverse32 ¶

func Reverse64 ¶

func Reverse8 ¶

func ReverseBytes ¶

func ReverseBytes16 ¶

func ReverseBytes32 ¶

func ReverseBytes64 ¶

func RotateLeft ¶

func RotateLeft16 ¶

func RotateLeft32 ¶

func RotateLeft64 ¶

func RotateLeft8 ¶

func Sub ¶ added in v1.12.0

func Sub32 ¶ added in v1.12.0

func Sub64 ¶ added in v1.12.0

func TrailingZeros ¶

func TrailingZeros16 ¶

func TrailingZeros32 ¶

func TrailingZeros64 ¶

func TrailingZeros8 ¶

Types ¶

Source Files ¶