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 }