Debian Codegraph @

src/SPERR/test_scripts/speck_int_unit_test.cpp

raw
1 #include "SPECK1D_INT_DEC.h"
2 #include "SPECK1D_INT_ENC.h"
3
4 #include "SPECK2D_INT_DEC.h"
5 #include "SPECK2D_INT_ENC.h"
6
7 #include "SPECK3D_INT_DEC.h"
8 #include "SPECK3D_INT_ENC.h"
9
10 #include "gtest/gtest.h"
11
12 #include <algorithm>
13 #include <cmath>
14 #include <random>
15
16 namespace {
17
18 template <typename T>
19 auto ProduceRandomArray(size_t len, float stddev, uint32_t seed)
20 -> std::pair<std::vector<T>, sperr::Bitmask>
21 {
22 std::mt19937 gen{seed};
23 std::normal_distribution<float> d{0.0, stddev};
24
25 auto tmp = std::vector<float>(len);
26 std::generate(tmp.begin(), tmp.end(), [&gen, &d]() { return d(gen); });
27
28 auto coeffs = std::vector<T>(len);
29 auto signs = sperr::Bitmask(len);
30 signs.reset_true();
31 for (size_t i = 0; i < len; i++) {
32 auto l = std::lround(std::abs(tmp[i]));
33 if (l > std::numeric_limits<T>::max())
34 coeffs[i] = std::numeric_limits<T>::max();
35 else
36 coeffs[i] = l;
37 // Only specify signs for non-zero values.
38 if (coeffs[i] != 0)
39 signs.wbit(i, (tmp[i] > 0.f));
40 }
41
42 return {coeffs, signs};
43 }
44
45 //
46 // Start 1D test cases
47 //
48 TEST(SPECK1D_INT, minimal)
49 {
50 const auto dims = sperr::dims_type{40, 1, 1};
51
52 auto input = std::vector<uint8_t>(dims[0], 0);
53 auto input_signs = sperr::Bitmask(input.size());
54 input_signs.reset_true();
55 input[4] = 1;
56 input[7] = 3;
57 input_signs.wfalse(7);
58 input[10] = 7;
59 input[11] = 9;
60 input_signs.wfalse(11);
61 input[16] = 10;
62 input[19] = 12;
63 input_signs.wfalse(19);
64 input[26] = 18;
65 input[29] = 19;
66 input_signs.wfalse(29);
67 input[32] = 32;
68 input[39] = 32;
69 input_signs.wfalse(39);
70
71 //
72 // Test 1-byte integer
73 //
74 {
75 auto encoder = sperr::SPECK1D_INT_ENC<uint8_t>();
76 encoder.use_coeffs(input, input_signs);
77 encoder.set_dims(dims);
78 encoder.encode();
79 auto bitstream = sperr::vec8_type();
80 encoder.append_encoded_bitstream(bitstream);
81
82 auto decoder = sperr::SPECK1D_INT_DEC<uint8_t>();
83 decoder.set_dims(dims);
84 decoder.use_bitstream(bitstream.data(), bitstream.size());
85 decoder.decode();
86 auto output = decoder.release_coeffs();
87 auto output_signs = decoder.release_signs();
88
89 EXPECT_EQ(encoder.integer_len(), 1);
90 EXPECT_EQ(decoder.integer_len(), 1);
91 EXPECT_EQ(input, output);
92 EXPECT_EQ(input_signs.size(), output_signs.size());
93 for (size_t i = 0; i < input_signs.size(); i++)
94 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
95 }
96
97 //
98 // Test 2-byte integer
99 //
100 auto input16 = std::vector<uint16_t>(dims[0], 0);
101 std::copy(input.cbegin(), input.cend(), input16.begin());
102 input16[30] = 300;
103 {
104 auto encoder = sperr::SPECK1D_INT_ENC<uint16_t>();
105 encoder.use_coeffs(input16, input_signs);
106 encoder.set_dims(dims);
107 encoder.encode();
108 auto bitstream = sperr::vec8_type();
109 encoder.append_encoded_bitstream(bitstream);
110
111 auto decoder = sperr::SPECK1D_INT_DEC<uint16_t>();
112 decoder.set_dims(dims);
113 decoder.use_bitstream(bitstream.data(), bitstream.size());
114 decoder.decode();
115 auto output = decoder.release_coeffs();
116 auto output_signs = decoder.release_signs();
117
118 EXPECT_EQ(encoder.integer_len(), 2);
119 EXPECT_EQ(decoder.integer_len(), 2);
120 EXPECT_EQ(input16, output);
121 EXPECT_EQ(input_signs.size(), output_signs.size());
122 for (size_t i = 0; i < input_signs.size(); i++)
123 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
124 }
125
126 //
127 // Test 4-byte integer
128 //
129 auto input32 = std::vector<uint32_t>(dims[0], 0);
130 std::copy(input16.cbegin(), input16.cend(), input32.begin());
131 input32[20] = 70'000;
132 {
133 auto encoder = sperr::SPECK1D_INT_ENC<uint32_t>();
134 encoder.use_coeffs(input32, input_signs);
135 encoder.set_dims(dims);
136 encoder.encode();
137 auto bitstream = sperr::vec8_type();
138 encoder.append_encoded_bitstream(bitstream);
139
140 auto decoder = sperr::SPECK1D_INT_DEC<uint32_t>();
141 decoder.set_dims(dims);
142 decoder.use_bitstream(bitstream.data(), bitstream.size());
143 decoder.decode();
144 auto output = decoder.release_coeffs();
145 auto output_signs = decoder.release_signs();
146
147 EXPECT_EQ(encoder.integer_len(), 4);
148 EXPECT_EQ(decoder.integer_len(), 4);
149 EXPECT_EQ(input32, output);
150 EXPECT_EQ(input_signs.size(), output_signs.size());
151 for (size_t i = 0; i < input_signs.size(); i++)
152 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
153 }
154
155 //
156 // Test 8-byte integer
157 //
158 auto input64 = std::vector<uint64_t>(dims[0], 0);
159 std::copy(input32.cbegin(), input32.cend(), input64.begin());
160 input64[23] = 5'000'700'000;
161 {
162 auto encoder = sperr::SPECK1D_INT_ENC<uint64_t>();
163 encoder.use_coeffs(input64, input_signs);
164 encoder.set_dims(dims);
165 encoder.encode();
166 auto bitstream = sperr::vec8_type();
167 encoder.append_encoded_bitstream(bitstream);
168
169 auto decoder = sperr::SPECK1D_INT_DEC<uint64_t>();
170 decoder.set_dims(dims);
171 decoder.use_bitstream(bitstream.data(), bitstream.size());
172 decoder.decode();
173 auto output = decoder.release_coeffs();
174 auto output_signs = decoder.release_signs();
175
176 EXPECT_EQ(encoder.integer_len(), 8);
177 EXPECT_EQ(decoder.integer_len(), 8);
178 EXPECT_EQ(input64, output);
179 EXPECT_EQ(input_signs.size(), output_signs.size());
180 for (size_t i = 0; i < input_signs.size(); i++)
181 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
182 }
183 }
184
185 TEST(SPECK1D_INT, Random1)
186 {
187 const auto dims = sperr::dims_type{2000, 1, 1};
188
189 auto [input, input_signs] = ProduceRandomArray<uint8_t>(dims[0], 2.9, 1);
190
191 // Encode
192 auto encoder = sperr::SPECK1D_INT_ENC<uint8_t>();
193 encoder.use_coeffs(input, input_signs);
194 encoder.set_dims(dims);
195 encoder.encode();
196 auto bitstream = sperr::vec8_type();
197 encoder.append_encoded_bitstream(bitstream);
198
199 // Decode
200 auto decoder = sperr::SPECK1D_INT_DEC<uint8_t>();
201 decoder.set_dims(dims);
202 decoder.use_bitstream(bitstream.data(), bitstream.size());
203 decoder.decode();
204 auto output = decoder.release_coeffs();
205 auto output_signs = decoder.release_signs();
206
207 EXPECT_EQ(input, output);
208 EXPECT_EQ(input_signs.size(), output_signs.size());
209 for (size_t i = 0; i < input_signs.size(); i++)
210 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
211 }
212
213 TEST(SPECK1D_INT, Random2)
214 {
215 const auto dims = sperr::dims_type{63 * 79 * 128, 1, 1};
216
217 auto [input, input_signs] = ProduceRandomArray<uint16_t>(dims[0], 499.0, 2);
218
219 // Encode
220 auto encoder = sperr::SPECK1D_INT_ENC<uint16_t>();
221 encoder.use_coeffs(input, input_signs);
222 encoder.set_dims(dims);
223 encoder.encode();
224 sperr::vec8_type bitstream;
225 encoder.append_encoded_bitstream(bitstream);
226
227 // Decode
228 auto decoder = sperr::SPECK1D_INT_DEC<uint16_t>();
229 decoder.set_dims(dims);
230 decoder.use_bitstream(bitstream.data(), bitstream.size());
231 decoder.decode();
232 auto output = decoder.release_coeffs();
233 auto output_signs = decoder.release_signs();
234
235 EXPECT_EQ(input, output);
236 EXPECT_EQ(input_signs.size(), output_signs.size());
237 for (size_t i = 0; i < input_signs.size(); i++)
238 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
239 }
240
241 TEST(SPECK1D_INT, RandomRandom)
242 {
243 const auto dims = sperr::dims_type{63 * 64 * 119, 1, 1};
244
245 auto rd = std::random_device();
246 auto [input, input_signs] = ProduceRandomArray<uint64_t>(dims[0], 8345.3, rd());
247
248 // Encode
249 auto encoder = sperr::SPECK1D_INT_ENC<uint64_t>();
250 encoder.use_coeffs(input, input_signs);
251 encoder.set_dims(dims);
252 encoder.encode();
253 auto bitstream = sperr::vec8_type();
254 encoder.append_encoded_bitstream(bitstream);
255
256 // Decode
257 auto decoder = sperr::SPECK1D_INT_DEC<uint64_t>();
258 decoder.set_dims(dims);
259 decoder.use_bitstream(bitstream.data(), bitstream.size());
260 decoder.decode();
261 auto output = decoder.release_coeffs();
262 auto output_signs = decoder.release_signs();
263
264 EXPECT_EQ(input, output);
265 EXPECT_EQ(input_signs.size(), output_signs.size());
266 for (size_t i = 0; i < input_signs.size(); i++)
267 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
268 }
269
270 //
271 // Starting 2D test cases
272 //
273 TEST(SPECK2D_INT, minimal)
274 {
275 const auto dims = sperr::dims_type{9, 8, 1};
276
277 auto input = std::vector<uint8_t>(dims[0] * dims[1], 0);
278 auto input_signs = sperr::Bitmask(input.size());
279 input_signs.reset_true();
280 input[2] = 1;
281 input_signs.wfalse(2);
282 input[4] = 1;
283 input[7] = 3;
284 input_signs.wfalse(7);
285 input[10] = 7;
286 input[11] = 9;
287 input_signs.wfalse(11);
288 input[16] = 10;
289 input[19] = 12;
290 input_signs.wfalse(19);
291 input[26] = 18;
292 input[29] = 19;
293 input_signs.wfalse(29);
294 input[32] = 32;
295 input[39] = 32;
296 input_signs.wfalse(39);
297 input[70] = 8;
298 input_signs.wfalse(70);
299 input[71] = 255;
300
301 //
302 // Test 1-byte integer
303 //
304 {
305 auto encoder = sperr::SPECK2D_INT_ENC<uint8_t>();
306 encoder.use_coeffs(input, input_signs);
307 encoder.set_dims(dims);
308 encoder.encode();
309 auto bitstream = sperr::vec8_type();
310 encoder.append_encoded_bitstream(bitstream);
311
312 auto decoder = sperr::SPECK2D_INT_DEC<uint8_t>();
313 decoder.set_dims(dims);
314 decoder.use_bitstream(bitstream.data(), bitstream.size());
315 decoder.decode();
316 auto output = decoder.release_coeffs();
317 auto output_signs = decoder.release_signs();
318
319 EXPECT_EQ(encoder.integer_len(), 1);
320 EXPECT_EQ(decoder.integer_len(), 1);
321 EXPECT_EQ(input, output);
322 EXPECT_EQ(input_signs.size(), output_signs.size());
323 for (size_t i = 0; i < input_signs.size(); i++)
324 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
325 }
326
327 //
328 // Test 2-byte integer
329 //
330 auto input16 = std::vector<uint16_t>(input.size());
331 std::copy(input.cbegin(), input.cend(), input16.begin());
332 input16[71] = 300;
333 {
334 auto encoder = sperr::SPECK2D_INT_ENC<uint16_t>();
335 encoder.use_coeffs(input16, input_signs);
336 encoder.set_dims(dims);
337 encoder.encode();
338 auto bitstream = sperr::vec8_type();
339 encoder.append_encoded_bitstream(bitstream);
340
341 auto decoder = sperr::SPECK2D_INT_DEC<uint16_t>();
342 decoder.set_dims(dims);
343 decoder.use_bitstream(bitstream.data(), bitstream.size());
344 decoder.decode();
345 auto output = decoder.release_coeffs();
346 auto output_signs = decoder.release_signs();
347
348 EXPECT_EQ(encoder.integer_len(), 2);
349 EXPECT_EQ(decoder.integer_len(), 2);
350 EXPECT_EQ(input16, output);
351 EXPECT_EQ(input_signs.size(), output_signs.size());
352 for (size_t i = 0; i < input_signs.size(); i++)
353 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
354 }
355
356 //
357 // Test 4-byte integer
358 //
359 auto input32 = std::vector<uint32_t>(input.size());
360 std::copy(input16.cbegin(), input16.cend(), input32.begin());
361 input32[66] = 70'000;
362 {
363 auto encoder = sperr::SPECK2D_INT_ENC<uint32_t>();
364 encoder.use_coeffs(input32, input_signs);
365 encoder.set_dims(dims);
366 encoder.encode();
367 auto bitstream = sperr::vec8_type();
368 encoder.append_encoded_bitstream(bitstream);
369
370 auto decoder = sperr::SPECK2D_INT_DEC<uint32_t>();
371 decoder.set_dims(dims);
372 decoder.use_bitstream(bitstream.data(), bitstream.size());
373 decoder.decode();
374 auto output = decoder.release_coeffs();
375 auto output_signs = decoder.release_signs();
376
377 EXPECT_EQ(encoder.integer_len(), 4);
378 EXPECT_EQ(decoder.integer_len(), 4);
379 EXPECT_EQ(input32, output);
380 EXPECT_EQ(input_signs.size(), output_signs.size());
381 for (size_t i = 0; i < input_signs.size(); i++)
382 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
383 }
384
385 //
386 // Test 8-byte integer
387 //
388 auto input64 = std::vector<uint64_t>(input.size());
389 std::copy(input32.cbegin(), input32.cend(), input64.begin());
390 input64[57] = 5'000'700'000;
391 {
392 auto encoder = sperr::SPECK2D_INT_ENC<uint64_t>();
393 encoder.use_coeffs(input64, input_signs);
394 encoder.set_dims(dims);
395 encoder.encode();
396 auto bitstream = sperr::vec8_type();
397 encoder.append_encoded_bitstream(bitstream);
398
399 auto decoder = sperr::SPECK2D_INT_DEC<uint64_t>();
400 decoder.set_dims(dims);
401 decoder.use_bitstream(bitstream.data(), bitstream.size());
402 decoder.decode();
403 auto output = decoder.release_coeffs();
404 auto output_signs = decoder.release_signs();
405
406 EXPECT_EQ(encoder.integer_len(), 8);
407 EXPECT_EQ(decoder.integer_len(), 8);
408 EXPECT_EQ(input64, output);
409 EXPECT_EQ(input_signs.size(), output_signs.size());
410 for (size_t i = 0; i < input_signs.size(); i++)
411 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
412 }
413 }
414
415 TEST(SPECK2D_INT, Random1)
416 {
417 const auto dims = sperr::dims_type{9, 20, 1};
418
419 auto [input, input_signs] = ProduceRandomArray<uint8_t>(dims[0] * dims[1], 2.9, 1);
420
421 // Encode
422 auto encoder = sperr::SPECK2D_INT_ENC<uint8_t>();
423 encoder.use_coeffs(input, input_signs);
424 encoder.set_dims(dims);
425 encoder.encode();
426 auto bitstream = sperr::vec8_type();
427 encoder.append_encoded_bitstream(bitstream);
428
429 // Decode
430 auto decoder = sperr::SPECK2D_INT_DEC<uint8_t>();
431 decoder.set_dims(dims);
432 decoder.use_bitstream(bitstream.data(), bitstream.size());
433 decoder.decode();
434 auto output = decoder.release_coeffs();
435 auto output_signs = decoder.release_signs();
436
437 EXPECT_EQ(input, output);
438 EXPECT_EQ(input_signs.size(), output_signs.size());
439 for (size_t i = 0; i < input_signs.size(); i++)
440 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
441 }
442
443 TEST(SPECK2D_INT, Random2)
444 {
445 const auto dims = sperr::dims_type{63, 130, 1};
446
447 auto [input, input_signs] = ProduceRandomArray<uint16_t>(dims[0] * dims[1], 499.0, 2);
448
449 // Encode
450 auto encoder = sperr::SPECK2D_INT_ENC<uint16_t>();
451 encoder.use_coeffs(input, input_signs);
452 encoder.set_dims(dims);
453 encoder.encode();
454 sperr::vec8_type bitstream;
455 encoder.append_encoded_bitstream(bitstream);
456
457 // Decode
458 auto decoder = sperr::SPECK2D_INT_DEC<uint16_t>();
459 decoder.set_dims(dims);
460 decoder.use_bitstream(bitstream.data(), bitstream.size());
461 decoder.decode();
462 auto output = decoder.release_coeffs();
463 auto output_signs = decoder.release_signs();
464
465 EXPECT_EQ(input, output);
466 EXPECT_EQ(input_signs.size(), output_signs.size());
467 for (size_t i = 0; i < input_signs.size(); i++)
468 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
469 }
470
471 TEST(SPECK2D_INT, RandomRandom)
472 {
473 const auto dims = sperr::dims_type{63, 256, 1};
474
475 auto rd = std::random_device();
476 auto [input, input_signs] = ProduceRandomArray<uint64_t>(dims[0] * dims[1], 8345.3, rd());
477
478 // Encode
479 auto encoder = sperr::SPECK2D_INT_ENC<uint64_t>();
480 encoder.use_coeffs(input, input_signs);
481 encoder.set_dims(dims);
482 encoder.encode();
483 auto bitstream = sperr::vec8_type();
484 encoder.append_encoded_bitstream(bitstream);
485
486 // Decode
487 auto decoder = sperr::SPECK2D_INT_DEC<uint64_t>();
488 decoder.set_dims(dims);
489 decoder.use_bitstream(bitstream.data(), bitstream.size());
490 decoder.decode();
491 auto output = decoder.release_coeffs();
492 auto output_signs = decoder.release_signs();
493
494 EXPECT_EQ(input, output);
495 EXPECT_EQ(input_signs.size(), output_signs.size());
496 for (size_t i = 0; i < input_signs.size(); i++)
497 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
498 }
499
500 //
501 // Starting 3D test cases
502 //
503 TEST(SPECK3D_INT, minimal)
504 {
505 const auto dims = sperr::dims_type{4, 3, 8};
506 const auto total_vals = dims[0] * dims[1] * dims[2];
507 auto input = std::vector<uint8_t>(total_vals, 0);
508 auto input_signs = sperr::Bitmask(input.size());
509 input_signs.reset_true();
510 input[4] = 1;
511 input[7] = 3;
512 input_signs.wfalse(7);
513 input[10] = 7;
514 input[11] = 9;
515 input_signs.wfalse(11);
516 input[16] = 10;
517 input[19] = 12;
518 input_signs.wfalse(19);
519 input[26] = 18;
520 input[29] = 19;
521 input_signs.wfalse(29);
522 input[32] = 32;
523 input[49] = 32;
524 input_signs.wfalse(49);
525 // Construct a value that's in between of signed and unsigned 8-bit int.
526 input[42] = uint8_t(std::numeric_limits<int8_t>::max()) + 8;
527
528 //
529 // Test 1-byte integers
530 //
531 {
532 auto encoder = sperr::SPECK3D_INT_ENC<uint8_t>();
533 encoder.use_coeffs(input, input_signs);
534 encoder.set_dims(dims);
535 encoder.encode();
536 auto bitstream = sperr::vec8_type();
537 encoder.append_encoded_bitstream(bitstream);
538
539 auto decoder = sperr::SPECK3D_INT_DEC<uint8_t>();
540 decoder.set_dims(dims);
541 decoder.use_bitstream(bitstream.data(), bitstream.size());
542 decoder.decode();
543 auto output = decoder.release_coeffs();
544 auto output_signs = decoder.release_signs();
545
546 EXPECT_EQ(encoder.integer_len(), 1);
547 EXPECT_EQ(decoder.integer_len(), 1);
548 EXPECT_EQ(input, output);
549 EXPECT_EQ(input, output);
550 EXPECT_EQ(input_signs.size(), output_signs.size());
551 for (size_t i = 0; i < input_signs.size(); i++)
552 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
553 }
554
555 //
556 // Test 2-byte integers
557 //
558 auto input16 = std::vector<uint16_t>(total_vals, 0);
559 std::copy(input.begin(), input.end(), input16.begin());
560 input16[30] = 300;
561 input_signs.wfalse(30);
562 // Construct a value that's in between of signed and unsigned 16-bit int.
563 input16[39] = uint16_t(std::numeric_limits<int16_t>::max()) + 16;
564 input_signs.wfalse(39);
565 {
566 auto encoder = sperr::SPECK3D_INT_ENC<uint16_t>();
567 encoder.use_coeffs(input16, input_signs);
568 encoder.set_dims(dims);
569 encoder.encode();
570 auto bitstream = sperr::vec8_type();
571 encoder.append_encoded_bitstream(bitstream);
572
573 auto decoder = sperr::SPECK3D_INT_DEC<uint16_t>();
574 decoder.set_dims(dims);
575 decoder.use_bitstream(bitstream.data(), bitstream.size());
576 decoder.decode();
577 auto output = decoder.release_coeffs();
578 auto output_signs = decoder.release_signs();
579
580 EXPECT_EQ(encoder.integer_len(), 2);
581 EXPECT_EQ(decoder.integer_len(), 2);
582 EXPECT_EQ(input16, output);
583 EXPECT_EQ(input16, output);
584 EXPECT_EQ(input_signs.size(), output_signs.size());
585 for (size_t i = 0; i < input_signs.size(); i++)
586 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
587 }
588
589 //
590 // Test 4-byte integers
591 //
592 auto input32 = std::vector<uint32_t>(total_vals, 0);
593 std::copy(input16.begin(), input16.end(), input32.begin());
594 input32[20] = 7'0300;
595 input_signs.wfalse(20);
596 // Construct a value that's in between of signed and unsigned 32-bit int.
597 input32[55] = uint32_t(std::numeric_limits<int32_t>::max()) + 32;
598 {
599 auto encoder = sperr::SPECK3D_INT_ENC<uint32_t>();
600 encoder.use_coeffs(input32, input_signs);
601 encoder.set_dims(dims);
602 encoder.encode();
603 auto bitstream = sperr::vec8_type();
604 encoder.append_encoded_bitstream(bitstream);
605
606 auto decoder = sperr::SPECK3D_INT_DEC<uint32_t>();
607 decoder.set_dims(dims);
608 decoder.use_bitstream(bitstream.data(), bitstream.size());
609 decoder.decode();
610 auto output = decoder.release_coeffs();
611 auto output_signs = decoder.release_signs();
612
613 EXPECT_EQ(encoder.integer_len(), 4);
614 EXPECT_EQ(decoder.integer_len(), 4);
615 EXPECT_EQ(input32, output);
616 EXPECT_EQ(input32, output);
617 EXPECT_EQ(input_signs.size(), output_signs.size());
618 for (size_t i = 0; i < input_signs.size(); i++)
619 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
620 }
621
622 //
623 // Test 8-byte integers
624 //
625 auto input64 = std::vector<uint64_t>(total_vals, 0);
626 std::copy(input32.begin(), input32.end(), input64.begin());
627 input64[27] = 5'000'700'990;
628 input_signs.wfalse(27);
629 // Construct a value that's in between of signed and unsigned 64-bit int.
630 input64[68] = uint64_t(std::numeric_limits<int64_t>::max()) + 64;
631 input_signs.wfalse(68);
632 {
633 auto encoder = sperr::SPECK3D_INT_ENC<uint64_t>();
634 encoder.use_coeffs(input64, input_signs);
635 encoder.set_dims(dims);
636 encoder.encode();
637 auto bitstream = sperr::vec8_type();
638 encoder.append_encoded_bitstream(bitstream);
639
640 auto decoder = sperr::SPECK3D_INT_DEC<uint64_t>();
641 decoder.set_dims(dims);
642 decoder.use_bitstream(bitstream.data(), bitstream.size());
643 decoder.decode();
644 auto output = decoder.release_coeffs();
645 auto output_signs = decoder.release_signs();
646
647 EXPECT_EQ(encoder.integer_len(), 8);
648 EXPECT_EQ(decoder.integer_len(), 8);
649 EXPECT_EQ(input64, output);
650 EXPECT_EQ(input64, output);
651 EXPECT_EQ(input_signs.size(), output_signs.size());
652 for (size_t i = 0; i < input_signs.size(); i++)
653 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
654 }
655 }
656
657 TEST(SPECK3D_INT, Random1)
658 {
659 const auto dims = sperr::dims_type{10, 20, 30};
660 const auto total_vals = dims[0] * dims[1] * dims[2];
661
662 auto [input, input_signs] = ProduceRandomArray<uint8_t>(total_vals, 2.9, 1);
663
664 // Encode
665 auto encoder = sperr::SPECK3D_INT_ENC<uint8_t>();
666 encoder.use_coeffs(input, input_signs);
667 encoder.set_dims(dims);
668 encoder.encode();
669 sperr::vec8_type bitstream;
670 encoder.append_encoded_bitstream(bitstream);
671
672 // Decode
673 auto decoder = sperr::SPECK3D_INT_DEC<uint8_t>();
674 decoder.set_dims(dims);
675 decoder.use_bitstream(bitstream.data(), bitstream.size());
676 decoder.decode();
677 auto output = decoder.release_coeffs();
678 auto output_signs = decoder.release_signs();
679
680 EXPECT_EQ(input, output);
681 EXPECT_EQ(input_signs.size(), output_signs.size());
682 for (size_t i = 0; i < input_signs.size(); i++)
683 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
684 }
685
686 TEST(SPECK3D_INT, Random2)
687 {
688 const auto dims = sperr::dims_type{63, 79, 128};
689 const auto total_vals = dims[0] * dims[1] * dims[2];
690
691 auto [input, input_signs] = ProduceRandomArray<uint16_t>(total_vals, 499.0, 2);
692
693 // Encode
694 auto encoder = sperr::SPECK3D_INT_ENC<uint16_t>();
695 encoder.use_coeffs(input, input_signs);
696 encoder.set_dims(dims);
697 encoder.encode();
698 sperr::vec8_type bitstream;
699 encoder.append_encoded_bitstream(bitstream);
700
701 // Decode
702 auto decoder = sperr::SPECK3D_INT_DEC<uint16_t>();
703 decoder.set_dims(dims);
704 decoder.use_bitstream(bitstream.data(), bitstream.size());
705 decoder.decode();
706 auto output = decoder.release_coeffs();
707 auto output_signs = decoder.release_signs();
708
709 EXPECT_EQ(input, output);
710 EXPECT_EQ(input_signs.size(), output_signs.size());
711 for (size_t i = 0; i < input_signs.size(); i++)
712 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
713 }
714
715 TEST(SPECK3D_INT, RandomRandom)
716 {
717 const auto dims = sperr::dims_type{63, 64, 119};
718 const auto total_vals = dims[0] * dims[1] * dims[2];
719
720 auto rd = std::random_device();
721 auto [input, input_signs] = ProduceRandomArray<uint64_t>(total_vals, 8345.3, rd());
722
723 // Encode
724 auto encoder = sperr::SPECK3D_INT_ENC<uint64_t>();
725 encoder.use_coeffs(input, input_signs);
726 encoder.set_dims(dims);
727 encoder.encode();
728 sperr::vec8_type bitstream;
729 encoder.append_encoded_bitstream(bitstream);
730
731 // Decode
732 auto decoder = sperr::SPECK3D_INT_DEC<uint64_t>();
733 decoder.set_dims(dims);
734 decoder.use_bitstream(bitstream.data(), bitstream.size());
735 decoder.decode();
736 auto output = decoder.release_coeffs();
737 auto output_signs = decoder.release_signs();
738
739 EXPECT_EQ(input, output);
740 EXPECT_EQ(input_signs.size(), output_signs.size());
741 for (size_t i = 0; i < input_signs.size(); i++)
742 EXPECT_EQ(input_signs.rbit(i), output_signs.rbit(i));
743 }
744
745 } // namespace