Debian Codegraph @

src/SPERR/test_scripts/outlier_coder_unit_test.cpp

raw
1 #include <algorithm>
2 #include <array>
3 #include <cassert>
4 #include <random>
5 #include "Outlier_Coder.h"
6 #include "gtest/gtest.h"
7
8 namespace {
9
10 using sperr::RTNType;
11
12 class outlier_tester {
13 private:
14 const size_t length = 0;
15 const double tolerance = 0.0;
16
17 std::vector<sperr::Outlier> LOS, recovered;
18
19 public:
20 // Constructor
21 outlier_tester(size_t l, double t) : length(l), tolerance(t){};
22
23 // A method to generate `N` outliers
24 // The resulting outliers will be stored in `LOS`, and returned.
25 auto gen_outliers(size_t N) -> const std::vector<sperr::Outlier>&
26 {
27 std::random_device rd{};
28 std::mt19937 gen{rd()};
29 std::normal_distribution<double> val_d{0.0, tolerance};
30 std::uniform_int_distribution<size_t> loc_d{0, length - 1};
31
32 LOS.clear();
33 LOS.reserve(N);
34 while (LOS.size() < N) {
35 double val = 0.0;
36 while (std::abs(val) <= tolerance)
37 val = val_d(gen);
38
39 // Make sure there ain't duplicate locations
40 auto loc = loc_d(gen);
41 while (std::any_of(LOS.begin(), LOS.end(), [loc](auto out) { return out.pos == loc; })) {
42 loc = loc_d(gen);
43 }
44 LOS.emplace_back(loc, val);
45 }
46
47 std::sort(LOS.begin(), LOS.end(), [](auto a, auto b) { return a.pos < b.pos; });
48 return LOS;
49 }
50
51 auto test_outliers() -> const std::vector<sperr::Outlier>&
52 {
53 // Create an encoder
54 sperr::Outlier_Coder encoder;
55 encoder.set_length(length);
56 encoder.set_tolerance(tolerance);
57 encoder.use_outlier_list(LOS);
58
59 if (encoder.encode() != RTNType::Good)
60 return recovered;
61 auto stream = sperr::vec8_type();
62 encoder.append_encoded_bitstream(stream);
63
64 // Create a decoder
65 sperr::Outlier_Coder decoder;
66 decoder.set_length(length);
67 decoder.set_tolerance(tolerance);
68 if (decoder.use_bitstream(stream.data(), stream.size()) != RTNType::Good)
69 return recovered;
70 if (decoder.decode() != RTNType::Good)
71 return recovered;
72
73 recovered = decoder.view_outlier_list();
74 std::sort(recovered.begin(), recovered.end(), [](auto a, auto b) { return a.pos < b.pos; });
75 return recovered;
76 }
77 };
78
79 TEST(sperr, small_num_outliers)
80 {
81 const double tolerance = 0.5;
82 outlier_tester tester(10, tolerance);
83 const auto& orig = tester.gen_outliers(3);
84 const auto& recovered = tester.test_outliers();
85 EXPECT_EQ(orig.size(), recovered.size());
86 for (size_t i = 0; i < orig.size(); i++) {
87 EXPECT_EQ(orig[i].pos, recovered[i].pos);
88 EXPECT_NEAR(orig[i].err, recovered[i].err, tolerance);
89 }
90 }
91
92 TEST(sperr, mid_num_outliers)
93 {
94 const double tolerance = 3e-4;
95 outlier_tester tester(10'000, tolerance);
96 const auto& orig = tester.gen_outliers(190);
97 const auto& recovered = tester.test_outliers();
98 EXPECT_EQ(orig.size(), recovered.size());
99 for (size_t i = 0; i < orig.size(); i++) {
100 EXPECT_EQ(orig[i].pos, recovered[i].pos);
101 EXPECT_NEAR(orig[i].err, recovered[i].err, tolerance);
102 }
103 }
104
105 TEST(sperr, large_num_outliers)
106 {
107 const double tolerance = 1e-7;
108 outlier_tester tester(900'000, tolerance);
109 const auto& orig = tester.gen_outliers(3900);
110 const auto& recovered = tester.test_outliers();
111 EXPECT_EQ(orig.size(), recovered.size());
112 for (size_t i = 0; i < orig.size(); i++) {
113 EXPECT_EQ(orig[i].pos, recovered[i].pos);
114 EXPECT_NEAR(orig[i].err, recovered[i].err, tolerance);
115 }
116 }
117
118 } // namespace