Helios++
Helios software for LiDAR simulations
RandomTest.h
1 #pragma once
2 
3 #include <noise/RandomnessGenerator.h>
4 
5 // Defines below are commented because they are only needed for old std::random
6 /*
7 #if defined(_WIN32) || defined(_WIN64)
8 #define exND1 0.300623, -1.42744, 0.0473341, -0.51204, -1.43744
9 #else
10 #define exND1 -1.42744, 0.300623, -0.51204, 0.0473341, 0.500384
11 #endif
12  */
13 
14 namespace HeliosTests {
15 
21 class RandomTest : public BaseTest {
22 public:
23  // *** CONSTRUCTION *** //
24  // ********************** //
28  RandomTest() : BaseTest("Randomness generation test"){}
29 
30  // *** R U N *** //
31  // *************** //
35  bool run() override;
36 };
37 
39  const double eps = 0.0001;
40  double diff;
41 
42  // Test random uniform real distribution generation with long seed
43  //double expectedURD1[] = {0.997185, 0.932557, 0.128124, 0.999041, 0.236089}; // Old std::random
44  double expectedURD1[] = { // New boost::random
45  0.417022, 0.997185, 0.720324, 0.932557, 0.000114
46  };
48  rg1.computeUniformRealDistribution(0.0, 1.0);
49  for(size_t i = 0 ; i < 5 ; i++){
50  diff = rg1.uniformRealDistributionNext() - expectedURD1[i];
51  if(diff < -eps || diff > eps) return false;
52  }
53 
54  // Test random uniform real distribution generation with double seed
55  /*double expectedURD2[] = { // Old std::random
56  -0.629836, 0.863082, 0.895461, -0.0305018, -0.358927
57  };*/
58  double expectedURD2[] = { // New boost::random
59  -0.12801, -0.629836, -0.948148, 0.863082, 0.099325
60  };
62  rg2.computeUniformRealDistribution(-1.0, 1.0);
63  for(size_t i = 0 ; i < 5 ; i++){
64  diff = rg2.uniformRealDistributionNext() - expectedURD2[i];
65  if(diff < -eps || diff > eps) return false;
66  }
67 
68  // Test random uniform real distribution with automatically generation
70  diff = rg3.uniformRealDistributionNext();
71  for(size_t i = 0 ; i < 4 ; i++){
72  // This comparison may lead to false fails, but not too often
73  if(rg3.uniformRealDistributionNext()==diff) return false;
74  }
75 
76  // Test random uniform real distribution with parse long seed
77  /*double expectedURD4[] = { // Old std::random
78  0.834397, 0.529073, 0.497834, 0.685763, 0.97071
79  };*/
80  double expectedURD4[] = { // New boost::random
81  0.045783, 0.834397, 0.586121, 0.529073, 0.20324
82  };
83  RandomnessGenerator<double> rg4("256");
84  for(size_t i = 0 ; i < 5 ; i++){
85  diff = rg4.uniformRealDistributionNext() - expectedURD4[i];
86  if(diff < -eps || diff > eps) return false;
87  }
88 
89  // Test random uniform real distribution with parse double seed
90  /*double expectedURD5[] = { // Old std::random
91  22.7339, 31.8972, 97.8223, 45.5585, 30.8013
92  };*/
93  double expectedURD5[] = { // New boost::random
94  7.63083, 22.7339, 77.9919, 31.8972, 43.8409
95  };
96  RandomnessGenerator<double> rg5("7.9");
97  rg5.computeUniformRealDistribution(0.0, 100.0);
98  for(size_t i = 0 ; i < 5 ; i++){
99  diff = rg5.uniformRealDistributionNext() - expectedURD5[i];
100  if(diff < -eps || diff > eps) return false;
101  }
102 
103  // Test random uniform real distribution with parse string timestamp seed
104  /*double expectedURD6[] = { // Old std::random
105  19.3035, -78.9788, 34.9037, -90.7673, -50.6285
106  };*/
107  double expectedURD6[] = { // New boost::random
108  -0.451698, 19.3035, -68.2896, -78.9788, -91.9135
109  };
110  RandomnessGenerator<double> rg6("2000-08-22 11:30:27");
111  rg6.computeUniformRealDistribution(-100.0, 50.0);
112  for(size_t i = 0 ; i < 5 ; i++){
113  diff = rg6.uniformRealDistributionNext() - expectedURD6[i];
114  if(diff < -eps || diff > eps) return false;
115  }
116 
117  // Test normal distribution
118  //double expectedND1[] = {exND1}; // Old std::random
119  double expectedND1[] = { // New boost::random
120  0.670678, -1.25429, 0.440081, 0.347027, -1.43913
121  };
122  RandomnessGenerator<double> rg7(1337);
123  for(size_t i = 0 ; i < 5 ; i++){
124  diff = rg7.normalDistributionNext() - expectedND1[i];
125  if(diff < -eps || diff > eps) return false;
126  }
127 
128  // Test swap, copy/move constructor and copy/move assignment
129  /*double expectedURD8[] = { // Old std::random
130  0.150989, 0.995869, 0.214838, 0.0899676, 0.18734, 0.0592914
131  };*/
132  double expectedURD8[] = { // New boost::random
133  0.803428, 0.150989, 0.527522, 0.995869, 0.119111, 0.214838
134  };
136  diff = rg8.uniformRealDistributionNext() - expectedURD8[0];
137  if(diff < -eps || diff > eps) return false;
138  RandomnessGenerator<double> rg8c(rg8);
139  diff = rg8c.uniformRealDistributionNext() - expectedURD8[1];
140  if(diff < -eps || diff > eps) return false;
141  rg8 = rg8c;
142  diff = rg8.uniformRealDistributionNext() - expectedURD8[2];
143  if(diff < -eps || diff > eps) return false;
144  rg8c = std::move(rg8);
145  diff = rg8c.uniformRealDistributionNext() - expectedURD8[3];
146  if(diff < -eps || diff > eps) return false;
147  RandomnessGenerator<double> rg8m(std::move(rg8c));
148  diff = rg8m.uniformRealDistributionNext() - expectedURD8[4];
149  if(diff < -eps || diff > eps) return false;
150  std::swap(rg8, rg8m);
151  diff = rg8.uniformRealDistributionNext() - expectedURD8[5];
152  if(diff < -eps || diff > eps) return false;
153 
154  // Test DEFAULT_RG behavior
155  RandomnessGenerator<double> drgCopy1(*DEFAULT_RG);
156  RandomnessGenerator<double> drgCopy2(*DEFAULT_RG);
157  for(size_t i = 0 ; i < 5 ; i++){
158  if(drgCopy1.uniformRealDistributionNext() ==
159  drgCopy2.uniformRealDistributionNext()
160  ){
161  // It could lead to false fails, but not too often
162  return false;
163  }
164  if(drgCopy1.normalDistributionNext() ==
165  drgCopy2.normalDistributionNext()
166  ){
167  // It could lead to false fails, but not too often
168  return false;
169  }
170  }
171  DEFAULT_RG->computeUniformRealDistribution(-1.0, 1.0);
172  DEFAULT_RG->computeNormalDistribution(4.0, 2.0);
173  RandomnessGenerator<double> drgCopy3(*DEFAULT_RG);
174  RandomnessGenerator<double> drgCopy4(*DEFAULT_RG);
175  for(size_t i = 0 ; i < 5 ; i++){
176  if(drgCopy3.uniformRealDistributionNext() !=
177  drgCopy4.uniformRealDistributionNext()
178  ){
179  return false;
180  }
181  if(drgCopy3.normalDistributionNext() !=
182  drgCopy4.normalDistributionNext()
183  ){
184  return false;
185  }
186  }
187 
188 
189 
190  // Successfully reached end of test
191  return true;
192 }
193 
194 
195 }
BaseTest class.
Definition: BaseTest.h:20
Test for randomness generation.
Definition: RandomTest.h:21
RandomTest()
Random test constructor.
Definition: RandomTest.h:28
bool run() override
Definition: RandomTest.h:38
RealType uniformRealDistributionNext()
Obtain the next value in the computed uniform real distribution.
Definition: RandomnessGenerator.h:394
void computeUniformRealDistribution(RealType lowerBound, RealType upperBound)
Compute a uniform real distribution using the specified real data type.
Definition: RandomnessGenerator.h:354
RealType normalDistributionNext()
Obtain the next value in the computed normal distribution.
Definition: RandomnessGenerator.h:432