Branch data Line data Source code
1 : : // *****************************************************************************
2 : : /*!
3 : : \file src/RNGTest/TestU01Stack.hpp
4 : : \copyright 2012-2015 J. Bakosi,
5 : : 2016-2018 Los Alamos National Security, LLC.,
6 : : 2019-2021 Triad National Security, LLC.
7 : : All rights reserved. See the LICENSE file for details.
8 : : \brief Stack of TestU01 RNG statistical tests
9 : : \details Stack of TestU01 RNG statistical tests
10 : : */
11 : : // *****************************************************************************
12 : : #ifndef TestU01Stack_h
13 : : #define TestU01Stack_h
14 : :
15 : : #include <vector>
16 : : #include <functional>
17 : : #include <iosfwd>
18 : : #include <map>
19 : : #include <tuple>
20 : : #include <type_traits>
21 : :
22 : : #include "NoWarning/value_factory.hpp"
23 : :
24 : : extern "C" {
25 : : #include <sres.h>
26 : : #include <sstring.h>
27 : : #include <sknuth.h>
28 : : #include <swalk.h>
29 : : #include <smarsa.h>
30 : : #include <scomp.h>
31 : : #include <sspectral.h>
32 : : #include <unif01.h>
33 : : #include <snpair.h>
34 : : }
35 : :
36 : : #include "StatTest.hpp"
37 : : #include "TestU01Util.hpp"
38 : : #include "Tags.hpp"
39 : : #include "TaggedTuple.hpp"
40 : : #include "Options/RNG.hpp"
41 : :
42 : : namespace rngtest {
43 : :
44 : : //! Stack of TestU01 RNG statistical tests
45 : : class TestU01Stack {
46 : :
47 : : public:
48 : : //! Constructor
49 : : explicit TestU01Stack();
50 : :
51 : : //! \brief Add a statistical test to battery
52 : : //! \details Note that adding a test to the battery does not invoke the test
53 : : //! constructor, it only records the information on how to call the test
54 : : //! constructor in the future. That is it binds the constructor arguments
55 : : //! to the constructor call and records the the information so only a
56 : : //! function call "()" is necessary to instantiate it.
57 : : //! \param[in] proxy Charm++ host proxy to which the test calls back to
58 : : //! \param[in] tests Vector of test constructors to add tests to
59 : : //! \param[in] r RNG ID enum
60 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
61 : : //! \param[in] names Vector of statisical test names (can be more than one
62 : : //! associated with a given test, since a test can contain more than one
63 : : //! statistical test evaluation, yielding multiple p-values)
64 : : //! \param[in] xargs Extra arguments to test-run
65 : : template< class TestType, class Proxy, typename... Ts >
66 : 264 : void add( Proxy& proxy,
67 : : std::vector< std::function< StatTest() > >& tests,
68 : : tk::ctr::RNGType r,
69 : : unif01_Gen* const gen,
70 : : std::vector< std::string >&& names,
71 : : Ts&&... xargs ) const
72 : : {
73 : : using Model = TestType;
74 : : using Host = StatTest;
75 : : using Props = typename TestType::Props;
76 [ + - ][ + - ]: 528 : tests.emplace_back(
[ + - ]
77 : : std::bind( boost::value_factory< Host >(),
78 : : std::function< Model() >(),
79 : : std::forward< Props >(
80 : 264 : Props( proxy, r, std::move(names), gen,
81 : 14 : std::forward<Ts>(xargs)... ) ) ) );
82 : 264 : }
83 : :
84 : : /** @name Stack of TestU01 statistical tests wrappers
85 : : * */
86 : : ///@{
87 : : static std::vector< double >
88 : : BirthdaySpacings( unif01_Gen* gen, sres_Poisson* res,
89 : : const std::tuple<long, long, int, long, int, int>& xargs );
90 : :
91 : : static std::vector< double >
92 : : Collision( unif01_Gen* gen, sknuth_Res2* res,
93 : : const std::tuple<long, long, int, long, int>& xargs );
94 : :
95 : : static std::vector< double >
96 : : Gap( unif01_Gen* gen, sres_Chi2* res,
97 : : const std::tuple<long, long, int, double, double>& xargs );
98 : :
99 : : static std::vector< double >
100 : : SimplePoker( unif01_Gen* gen, sres_Chi2* res,
101 : : const std::tuple<long, long, int, int, int>& xargs );
102 : :
103 : : static std::vector< double >
104 : : CouponCollector( unif01_Gen* gen, sres_Chi2* res,
105 : : const std::tuple<long, long, int, int>& xargs );
106 : :
107 : : static std::vector< double >
108 : : MaxOft( unif01_Gen* gen, sknuth_Res1* res,
109 : : const std::tuple<long, long, int, int, int, int, int>& xargs );
110 : :
111 : : static std::vector< double >
112 : : WeightDistrib( unif01_Gen* gen, sres_Chi2* res,
113 : : const std::tuple<long, long, int, long, double, double>& xargs );
114 : :
115 : : static std::vector< double >
116 : : MatrixRank( unif01_Gen* gen, sres_Chi2* res,
117 : : const std::tuple<long, long, int, int, int, int>& xargs );
118 : :
119 : : static std::vector< double >
120 : : HammingIndep( unif01_Gen* gen, sstring_Res* res,
121 : : const std::tuple<long, long, int, int, int, int>& xargs );
122 : :
123 : : static std::vector< double >
124 : : RandomWalk1( unif01_Gen* gen, swalk_Res* res,
125 : : const std::tuple<long, long, int, int, long, long>& xargs );
126 : :
127 : : static std::vector< double >
128 : : SerialOver( unif01_Gen* gen, sres_Basic* res,
129 : : const std::tuple<long, long, int, long, int>& xargs );
130 : :
131 : : static std::vector< double >
132 : : CollisionOver( unif01_Gen* gen, smarsa_Res* res,
133 : : const std::tuple<long, long, int, long, int>& xargs );
134 : :
135 : : static std::vector< double >
136 : : ClosePairs( unif01_Gen* gen, snpair_Res* res,
137 : : const std::tuple<long, long, int, int, int, int, int>& xargs );
138 : :
139 : : static std::vector< double >
140 : : ClosePairsBitMatch( unif01_Gen* gen, snpair_Res* res,
141 : : const std::tuple<long, long, int, int>& xargs );
142 : :
143 : : static std::vector< double >
144 : : Run( unif01_Gen* gen, sres_Chi2* res,
145 : : const std::tuple<long, long, int, int>& xargs );
146 : :
147 : : static std::vector< double >
148 : : Permutation( unif01_Gen* gen, sres_Chi2* res,
149 : : const std::tuple<long, long, int, int>& xargs );
150 : :
151 : : static std::vector< double >
152 : : CollisionPermut( unif01_Gen* gen, sknuth_Res2* res,
153 : : const std::tuple<long, long, int, int>& xargs );
154 : :
155 : : static std::vector< double >
156 : : SampleProd( unif01_Gen* gen, sres_Basic* res,
157 : : const std::tuple<long, long, int, int>& xargs );
158 : :
159 : : static std::vector< double >
160 : : SampleMean( unif01_Gen* gen, sres_Basic* res,
161 : : const std::tuple<long, long, int>& xargs );
162 : :
163 : : static std::vector< double >
164 : : SampleCorr( unif01_Gen* gen, sres_Basic* res,
165 : : const std::tuple<long, long, int, int>& xargs );
166 : :
167 : : static std::vector< double >
168 : : AppearanceSpacings( unif01_Gen* gen, sres_Basic* res,
169 : : const std::tuple<long, long, long, int, int, int>& xargs );
170 : :
171 : : static std::vector< double >
172 : : SumCollector( unif01_Gen* gen, sres_Chi2* res,
173 : : const std::tuple<long, long, int, double>& xargs );
174 : :
175 : : static std::vector< double >
176 : : Savir2( unif01_Gen* gen, sres_Chi2* res,
177 : : const std::tuple<long, long, int, long, int>& xargs );
178 : :
179 : : static std::vector< double >
180 : : GCD( unif01_Gen* gen, smarsa_Res2* res,
181 : : const std::tuple<long, long, int, int>& xargs );
182 : :
183 : : static std::vector< double >
184 : : LinearComp( unif01_Gen* gen, scomp_Res* res,
185 : : const std::tuple<long, long, int, int>& xargs );
186 : :
187 : : static std::vector< double >
188 : : LempelZiv( unif01_Gen* gen, sres_Basic* res,
189 : : const std::tuple<long, int, int, int>& xargs );
190 : :
191 : : static std::vector< double >
192 : : Fourier3( unif01_Gen* gen, sspectral_Res* res,
193 : : const std::tuple<long, int, int, int>& xargs );
194 : :
195 : : static std::vector< double >
196 : : LongestHeadRun( unif01_Gen* gen, sstring_Res2* res,
197 : : const std::tuple<long, long, int, int, long>& xargs );
198 : :
199 : : static std::vector< double >
200 : : PeriodsInStrings( unif01_Gen* gen, sres_Chi2* res,
201 : : const std::tuple<long, long, int, int>& xargs );
202 : :
203 : : static std::vector< double >
204 : : HammingWeight2( unif01_Gen* gen, sres_Basic* res,
205 : : const std::tuple<long, long, int, int, long>& xargs );
206 : :
207 : : static std::vector< double >
208 : : HammingCorr( unif01_Gen* gen, sstring_Res* res,
209 : : const std::tuple<long, long, int, int, int>& xargs );
210 : :
211 : : static std::vector< double >
212 : : StringRun( unif01_Gen* gen, sstring_Res3* res,
213 : : const std::tuple<long, long, int, int>& xargs );
214 : :
215 : : static std::vector< double >
216 : : AutoCorr( unif01_Gen* gen, sres_Basic* res,
217 : : const std::tuple<long, long, int, int, int>& xargs );
218 : : ///@}
219 : :
220 : : //! Function pointer type to use to define pointers to test runner functions
221 : : //! \note Abstracting the function pointer away as this, also pleases
222 : : //! doxygen in client code, otherwise doxygen issues warnings, such as
223 : : //! `no matching class member found for` as it fails to parse the
224 : : //! function pointer correctly and fails to find a function declaration,
225 : : //! which, of course, does not exist. Thanks to Vladimír Vondruš,
226 : : //! author of m.css (http://mcss.mosra.cz) for the help with this.
227 : : template< class... Args > using FnPtr = std::vector<double>(*)( Args... );
228 : :
229 : : //! \brief Compile-time tag-based access to individual test wrappers.
230 : : //! \details This tagged tuple is practically a compile-time map that
231 : : //! associates tags (empty structs) to test wrappers. This is used to find
232 : : //! the test wrapper function pointers after migration over the network.
233 : : //! \see See also TestU01Props::pup().
234 : : tk::TaggedTuple< brigand::list<
235 : :
236 : : tag::BirthdaySpacings, // tag
237 : : FnPtr< unif01_Gen*, sres_Poisson*,
238 : : const std::tuple<long, long, int, long, int, int>& >,
239 : :
240 : : tag::Collision,
241 : : FnPtr< unif01_Gen*, sknuth_Res2*,
242 : : const std::tuple<long, long, int, long, int>& >,
243 : :
244 : : tag::RandomWalk1,
245 : : FnPtr< unif01_Gen*, swalk_Res*,
246 : : const std::tuple<long, long, int, int, long, long>& >,
247 : :
248 : : tag::Gap,
249 : : FnPtr< unif01_Gen*, sres_Chi2*,
250 : : const std::tuple<long, long, int, double, double>& >,
251 : :
252 : : tag::SimplePoker,
253 : : FnPtr< unif01_Gen*, sres_Chi2*,
254 : : const std::tuple<long, long, int, int, int>& >,
255 : :
256 : : tag::CouponCollector,
257 : : FnPtr< unif01_Gen*, sres_Chi2*,
258 : : const std::tuple<long, long, int, int>& >,
259 : :
260 : : tag::MaxOft,
261 : : FnPtr< unif01_Gen*, sknuth_Res1*,
262 : : const std::tuple<long, long, int, int, int, int, int>& >,
263 : :
264 : : tag::WeightDistrib,
265 : : FnPtr< unif01_Gen*, sres_Chi2*,
266 : : const std::tuple<long, long, int, long, double, double>& >,
267 : :
268 : : tag::MatrixRank,
269 : : FnPtr< unif01_Gen*, sres_Chi2*,
270 : : const std::tuple<long, long, int, int, int, int>& >,
271 : :
272 : : tag::HammingIndep,
273 : : FnPtr< unif01_Gen*, sstring_Res*,
274 : : const std::tuple<long, long, int, int, int, int>& >,
275 : :
276 : : tag::SerialOver,
277 : : FnPtr< unif01_Gen*, sres_Basic*,
278 : : const std::tuple<long, long, int, long, int>& >,
279 : :
280 : : tag::CollisionOver,
281 : : FnPtr< unif01_Gen*, smarsa_Res*,
282 : : const std::tuple<long, long, int, long, int>& >,
283 : :
284 : : tag::ClosePairs,
285 : : FnPtr< unif01_Gen*, snpair_Res*,
286 : : const std::tuple<long, long, int, int, int, int, int>& >,
287 : :
288 : : tag::ClosePairsBitMatch,
289 : : FnPtr< unif01_Gen*, snpair_Res*,
290 : : const std::tuple<long, long, int, int>& >,
291 : :
292 : : tag::Run,
293 : : FnPtr< unif01_Gen*, sres_Chi2*,
294 : : const std::tuple<long, long, int, int>& >,
295 : :
296 : : tag::Permutation,
297 : : FnPtr< unif01_Gen*, sres_Chi2*,
298 : : const std::tuple<long, long, int, int>& >,
299 : :
300 : : tag::CollisionPermut,
301 : : FnPtr< unif01_Gen*, sknuth_Res2*,
302 : : const std::tuple<long, long, int, int>& >,
303 : :
304 : : tag::SampleProd,
305 : : FnPtr< unif01_Gen*, sres_Basic*,
306 : : const std::tuple<long, long, int, int>& >,
307 : :
308 : : tag::SampleMean,
309 : : FnPtr< unif01_Gen*, sres_Basic*,
310 : : const std::tuple<long, long, int>& >,
311 : :
312 : : tag::SampleCorr,
313 : : FnPtr< unif01_Gen*, sres_Basic*,
314 : : const std::tuple<long, long, int, int>& >,
315 : :
316 : : tag::AppearanceSpacings,
317 : : FnPtr< unif01_Gen*, sres_Basic*,
318 : : const std::tuple<long, long, long, int, int, int>& >,
319 : :
320 : : tag::SumCollector,
321 : : FnPtr< unif01_Gen*, sres_Chi2*,
322 : : const std::tuple<long, long, int, double>& >,
323 : :
324 : : tag::Savir2,
325 : : FnPtr< unif01_Gen*, sres_Chi2*,
326 : : const std::tuple<long, long, int, long, int>& >,
327 : :
328 : : tag::GCD,
329 : : FnPtr< unif01_Gen*, smarsa_Res2*,
330 : : const std::tuple<long, long, int, int>& >,
331 : :
332 : : tag::LinearComp,
333 : : FnPtr< unif01_Gen*, scomp_Res*,
334 : : const std::tuple<long, long, int, int>& >,
335 : :
336 : : tag::LempelZiv,
337 : : FnPtr< unif01_Gen*, sres_Basic*,
338 : : const std::tuple<long, int, int, int>& >,
339 : :
340 : : tag::Fourier3,
341 : : FnPtr< unif01_Gen*, sspectral_Res*,
342 : : const std::tuple<long, int, int, int>& >,
343 : :
344 : : tag::LongestHeadRun,
345 : : FnPtr< unif01_Gen*, sstring_Res2*,
346 : : const std::tuple<long, long, int, int, long>& >,
347 : :
348 : : tag::PeriodsInStrings,
349 : : FnPtr< unif01_Gen*, sres_Chi2*,
350 : : const std::tuple<long, long, int, int>& >,
351 : :
352 : : tag::HammingWeight2,
353 : : FnPtr< unif01_Gen*, sres_Basic*,
354 : : const std::tuple<long, long, int, int, long>& >,
355 : :
356 : : tag::HammingCorr,
357 : : FnPtr< unif01_Gen*, sstring_Res*,
358 : : const std::tuple<long, long, int, int, int>& >,
359 : :
360 : : tag::StringRun,
361 : : FnPtr< unif01_Gen*, sstring_Res3*,
362 : : const std::tuple<long, long, int, int>& >,
363 : :
364 : : tag::AutoCorr,
365 : : FnPtr< unif01_Gen*, sres_Basic*,
366 : : const std::tuple<long, long, int, int, int>& >
367 : :
368 : : > > runner {{
369 : :
370 : : BirthdaySpacings, // Initialize by binding to member function wrappers.
371 : : Collision, // Obviously the order here is important.
372 : : RandomWalk1,
373 : : Gap,
374 : : SimplePoker,
375 : : CouponCollector,
376 : : MaxOft,
377 : : WeightDistrib,
378 : : MatrixRank,
379 : : HammingIndep,
380 : : SerialOver,
381 : : CollisionOver,
382 : : ClosePairs,
383 : : ClosePairsBitMatch,
384 : : Run,
385 : : Permutation,
386 : : CollisionPermut,
387 : : SampleProd,
388 : : SampleMean,
389 : : SampleCorr,
390 : : AppearanceSpacings,
391 : : SumCollector,
392 : : Savir2,
393 : : GCD,
394 : : LinearComp,
395 : : LempelZiv,
396 : : Fourier3,
397 : : LongestHeadRun,
398 : : PeriodsInStrings,
399 : : HammingWeight2,
400 : : HammingCorr,
401 : : StringRun,
402 : : AutoCorr
403 : :
404 : : }};
405 : :
406 : : //! Find RNG properties based on RNG id
407 : : unif01_Gen* generator( tk::ctr::RNGType r ) const;
408 : :
409 : : private:
410 : : //! Create TestU01 RNG wrapper
411 : : template< tk::ctr::RawRNGType id > void addRNG( tk::ctr::RNGType r );
412 : :
413 : : std::map< tk::ctr::RNGType, Gen01Ptr > m_generator; //!< RNG wrappers
414 : : };
415 : :
416 : : } // rngtest::
417 : :
418 : : #endif // TestU01Stack_h
|
