github.com/tunabay/go-bitarray@v1.3.1/bitarray_example_test.go (about)

     1  // Copyright (c) 2021 Hirotsuna Mizuno. All rights reserved.
     2  // Use of this source code is governed by the MIT license that can be found in
     3  // the LICENSE file.
     4  
     5  package bitarray_test
     6  
     7  import (
     8  	"crypto/md5"
     9  	"crypto/sha256"
    10  	"fmt"
    11  
    12  	"github.com/tunabay/go-bitarray"
    13  )
    14  
    15  func Example_bitLayout() {
    16  	// This example assumes 8-byte data with the following bit layout, and
    17  	// accesses the 5-bit integer X and the 50-bit integer Y in it.
    18  	//
    19  	//   |0              |1              |2              |3              |
    20  	//   |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|
    21  	//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    22  	//   | 9-bit flag area | 5-bit X | Upper 18 bits of the 50-bit int Y |
    23  	//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    24  	//   |               Lower 32 bits of the 50-bit int Y               |
    25  	//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    26  	data := make([]byte, 8)
    27  	buf := bitarray.NewBufferFromByteSlice(data)
    28  
    29  	// set 9-bit flag area to 110000011
    30  	buf.PutBitAt(0, 1)
    31  	buf.PutBitAt(1, 1)
    32  	buf.PutBitAt(7, 1)
    33  	buf.PutBitAt(8, 1)
    34  
    35  	// set 5-bit integer X
    36  	buf.Slice(9, 14).PutUint8(25) // = 0b_11001
    37  
    38  	// set 50-bit integer Y
    39  	buf.Slice(14, 64).PutUint64(0x_3_f0ff_f0f0_ff0f)
    40  
    41  	// raw bytes updated
    42  	fmt.Printf("%08b\n%08b\n", data[:4], data[4:])
    43  
    44  	// read fields
    45  	fmt.Printf("F = %b\n", buf.Slice(0, 9))
    46  	fmt.Printf("X = %d\n", buf.Slice(9, 14).Uint8())
    47  	fmt.Printf("Y = %x\n", buf.SliceToEnd(14).Uint64())
    48  
    49  	// Output:
    50  	// [11000001 11100111 11110000 11111111]
    51  	// [11110000 11110000 11111111 00001111]
    52  	// F = 110000011
    53  	// X = 25
    54  	// Y = 3f0fff0f0ff0f
    55  }
    56  
    57  func Example_bitArray() {
    58  	// Parse string representation
    59  	ba1, err := bitarray.Parse("111000")
    60  	if err != nil {
    61  		panic(err)
    62  	}
    63  	fmt.Println(ba1)
    64  
    65  	// Slice and Repeat
    66  	ba2 := ba1.Slice(2, 5).Repeat(2)
    67  	fmt.Println(ba2)
    68  
    69  	// Append
    70  	ba3 := ba2.Append(bitarray.MustParse("101011"))
    71  	fmt.Printf("% b\n", ba3) // alternative formatting
    72  
    73  	// Extract bits from []byte across byte boundary
    74  	buf := []byte{0xff, 0x00}
    75  	ba4 := bitarray.NewFromBytes(buf, 4, 7)
    76  	fmt.Println(ba4)
    77  
    78  	// Output:
    79  	// 111000
    80  	// 100100
    81  	// 10010010 1011
    82  	// 1111000
    83  }
    84  
    85  func ExampleNew() {
    86  	ba := bitarray.New(0, 0, 1, 1, 0, 1)
    87  	fmt.Printf("%s\n", ba)
    88  
    89  	// Output:
    90  	// 001101
    91  }
    92  
    93  func ExampleNewFromBytes() {
    94  	b := []byte{0b_1010_1111, 0b_0101_0011}
    95  	ba := bitarray.NewFromBytes(b, 2, 12)
    96  	fmt.Printf("% b\n", ba)
    97  
    98  	// Output:
    99  	// 10111101 0100
   100  }
   101  
   102  func ExampleNewFromByteBits() {
   103  	bits := []byte{0, 1, 1, 0, 0, 0, 1, 1, 1, 1}
   104  	ba := bitarray.NewFromByteBits(bits)
   105  	fmt.Printf("% b\n", ba)
   106  
   107  	// Output:
   108  	// 01100011 11
   109  }
   110  
   111  func ExampleNewZeroFilled() {
   112  	ba := bitarray.NewZeroFilled(42)
   113  	fmt.Printf("% b\n", ba)
   114  
   115  	// Output:
   116  	// 00000000 00000000 00000000 00000000 00000000 00
   117  }
   118  
   119  func ExampleNewOneFilled() {
   120  	ba := bitarray.NewOneFilled(28)
   121  	fmt.Printf("% b\n", ba)
   122  
   123  	// Output:
   124  	// 11111111 11111111 11111111 1111
   125  }
   126  
   127  func ExampleNewByRunLength() {
   128  	ba1 := bitarray.NewByRunLength(1, 2, 3, 4, 5, 6)
   129  	ba2 := bitarray.NewByRunLength(0, 1, 1, 2, 3, 5, 8, 13)
   130  	fmt.Printf("% b\n", ba1)
   131  	fmt.Printf("% b\n", ba2)
   132  
   133  	// Output:
   134  	// 01100011 11000001 11111
   135  	// 10110001 11110000 00001111 11111111 1
   136  }
   137  
   138  func ExampleBitArray_IsZero() {
   139  	ba1 := bitarray.MustParse("")
   140  	ba2 := bitarray.MustParse("0")
   141  	ba3 := bitarray.MustParse("00000000")
   142  	fmt.Println(ba1.IsZero())
   143  	fmt.Println(ba2.IsZero())
   144  	fmt.Println(ba3.IsZero())
   145  
   146  	// Output:
   147  	// true
   148  	// false
   149  	// false
   150  }
   151  
   152  func ExampleBitArray_Len() {
   153  	ba1 := bitarray.MustParse("1111-0000 1111-0000 111")
   154  	ba2 := bitarray.MustParse("101")
   155  	ba3 := bitarray.MustParse("")
   156  	fmt.Println(ba1.Len())
   157  	fmt.Println(ba2.Len())
   158  	fmt.Println(ba3.Len())
   159  
   160  	// Output:
   161  	// 19
   162  	// 3
   163  	// 0
   164  }
   165  
   166  func ExampleBitArray_NumPadding() {
   167  	ba1 := bitarray.MustParse("11110000 11110000")
   168  	ba2 := bitarray.MustParse("11110000 11110000 000")
   169  	ba3 := bitarray.MustParse("11110000 11110000 000000")
   170  	fmt.Println(ba1.NumPadding())
   171  	fmt.Println(ba2.NumPadding())
   172  	fmt.Println(ba3.NumPadding())
   173  
   174  	// Output:
   175  	// 0
   176  	// 5
   177  	// 2
   178  }
   179  
   180  func ExampleBitArray_String() {
   181  	ba := bitarray.MustParse("0000-1111 0000-1111 0000-1")
   182  	fmt.Printf("%s\n", ba.String())
   183  	fmt.Println(ba)
   184  
   185  	// Output:
   186  	// 000011110000111100001
   187  	// 000011110000111100001
   188  }
   189  
   190  func ExampleBitArray_Bytes() {
   191  	ba := bitarray.MustParse("11111111 00000000 1110")
   192  	bs, npad := ba.Bytes()
   193  	fmt.Printf("%x, npad=%d\n", bs, npad)
   194  
   195  	// Output:
   196  	// ff00e0, npad=4
   197  }
   198  
   199  func ExampleBitArray_BitAt() {
   200  	ba := bitarray.MustParse("10001000 10")
   201  	fmt.Println(ba.BitAt(0), ba.BitAt(4), ba.BitAt(8))
   202  
   203  	// Output:
   204  	// 1 1 1
   205  }
   206  
   207  func ExampleBitArray_Hash_sha256() {
   208  	ba1 := bitarray.MustParse("11111110 11111111 0000")
   209  	ba2 := bitarray.MustParse("11111111 11111111 0000")
   210  	ba3 := bitarray.MustParse("11111111 11111111 00000")
   211  	fmt.Printf("%x\n", ba1.Hash(sha256.New()))
   212  	fmt.Printf("%x\n", ba2.Hash(sha256.New()))
   213  	fmt.Printf("%x\n", ba3.Hash(sha256.New()))
   214  
   215  	// Output:
   216  	// 9c5dfdfd1abe7dc4c5018ed54f338bc1c7e9ec70769cd37bda4e826d389f8ba0
   217  	// 42f0862649c6f51d8aaa31d810d9c2e4455917b61b0b17f13fbd66007cb6d75e
   218  	// 074d99c983072816cbc8d980c4a2fd441f6036aca06f83ee14e05cab5afbed85
   219  }
   220  
   221  func ExampleBitArray_Hash_md5() {
   222  	ba1 := bitarray.MustParse("11111110 11111111 0000")
   223  	ba2 := bitarray.MustParse("11111111 11111111 0000")
   224  	ba3 := bitarray.MustParse("11111111 11111111 00000")
   225  	fmt.Printf("%x\n", ba1.Hash(md5.New()))
   226  	fmt.Printf("%x\n", ba2.Hash(md5.New()))
   227  	fmt.Printf("%x\n", ba3.Hash(md5.New()))
   228  
   229  	// Output:
   230  	// 734a8ff2ae91df5975e32c95cf83d88e
   231  	// 2241281d24ea5e99500ff0b2f925709e
   232  	// 9f51432b4c47d144039b8259564bb89b
   233  }
   234  
   235  func ExampleBitArray_MapKey() {
   236  	ba1 := bitarray.MustParse("1010-1100 0")
   237  	ba2 := bitarray.MustParse("1010-1100 00")
   238  	ba3 := bitarray.MustParse("")
   239  
   240  	m := make(map[string]string)
   241  	m[ba1.MapKey()] = "ba1"
   242  	m[ba2.MapKey()] = "ba2"
   243  	m[ba3.MapKey()] = "ba3"
   244  
   245  	for k, v := range m {
   246  		fmt.Printf("%q -> %s\n", k, v)
   247  	}
   248  
   249  	// Unordered output:
   250  	// "\x01\xac\x00" -> ba1
   251  	// "\x02\xac\x00" -> ba2
   252  	// "" -> ba3
   253  }
   254  
   255  func ExampleBitArray_ToPadded8() {
   256  	ba1 := bitarray.MustParse("1111")
   257  	ba2 := bitarray.MustParse("1111-1111 1")
   258  	ba3 := bitarray.MustParse("1111-1111 1111-1111")
   259  	fmt.Printf("% b\n", ba1.ToPadded8())
   260  	fmt.Printf("% b\n", ba2.ToPadded8())
   261  	fmt.Printf("% b\n", ba3.ToPadded8())
   262  
   263  	// Output:
   264  	// 11110000
   265  	// 11111111 10000000
   266  	// 11111111 11111111
   267  }
   268  
   269  func ExampleBitArray_ToPadded64() {
   270  	ba1 := bitarray.MustParse("1111-11")
   271  	ba2 := bitarray.MustParse("0x_ffff_ffff_ffff")
   272  	fmt.Printf("% x\n", ba1.ToPadded64())
   273  	fmt.Printf("% x\n", ba2.ToPadded64())
   274  
   275  	// Output:
   276  	// fc000000 00000000
   277  	// ffffffff ffff0000
   278  }
   279  
   280  func ExampleBitArray_ToByteBits() {
   281  	ba1 := bitarray.MustParse("101010")
   282  	ba2 := bitarray.MustParse("0000-1111 1111")
   283  	fmt.Printf("%d\n", ba1.ToByteBits())
   284  	fmt.Printf("%d\n", ba2.ToByteBits())
   285  
   286  	// Output:
   287  	// [1 0 1 0 1 0]
   288  	// [0 0 0 0 1 1 1 1 1 1 1 1]
   289  }
   290  
   291  func ExampleBitArray_ParityBit() {
   292  	ba1 := bitarray.MustParse("0000-000")
   293  	ba2 := bitarray.MustParse("1010-001")
   294  	ba3 := bitarray.MustParse("1111-111")
   295  	fmt.Println(ba1.ParityBit())
   296  	fmt.Println(ba2.ParityBit())
   297  	fmt.Println(ba3.ParityBit())
   298  
   299  	// Output:
   300  	// 1
   301  	// 0
   302  	// 0
   303  }
   304  
   305  func ExampleBitArray_RepeatEach() {
   306  	ba := bitarray.MustParse("0101-0011 001")
   307  	fmt.Printf("% b\n", ba.RepeatEach(2))
   308  	fmt.Printf("% b\n", ba.RepeatEach(3))
   309  	fmt.Printf("[% b]\n", ba.RepeatEach(0))
   310  
   311  	// Output:
   312  	// 00110011 00001111 000011
   313  	// 00011100 01110000 00111111 00000011 1
   314  	// []
   315  }