Branch data Line data Source code
1 : : // *****************************************************************************
2 : : /*!
3 : : \file src/RNGTest/TestU01Stack.cpp
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 : :
13 : : #include <array>
14 : : #include <iterator>
15 : : #include <memory>
16 : : #include <utility>
17 : : #include <cfenv>
18 : :
19 : : #include "Tags.hpp"
20 : : #include "Exception.hpp"
21 : : #include "TestU01Stack.hpp"
22 : : #include "TestU01Wrappers.hpp"
23 : : #include "RNGTest/InputDeck/InputDeck.hpp"
24 : : #include "QuinoaBuildConfig.hpp"
25 : :
26 : : extern "C" {
27 : : #include <svaria.h>
28 : : #include <gofw.h>
29 : : #include <snpair.h>
30 : : }
31 : :
32 : : namespace rngtest {
33 : :
34 : : extern ctr::InputDeck g_inputdeck;
35 : :
36 : : } // rngtest::
37 : :
38 : : using rngtest::TestU01Stack;
39 : :
40 : 176 : TestU01Stack::TestU01Stack() : m_generator()
41 : : // *****************************************************************************
42 : : // Constructor
43 : : //! \details Associate RNGs to global-scope wrappers. Admittedly, this code is
44 : : //! ugly and looks stupid at first sight. However, this is a translation of
45 : : //! runtime information (user-selected RNGs) to compile-time information:
46 : : //! associating RNG ids from an enum class, tk::ctr::RNGType::value, to a
47 : : //! compile-time constant, underlying_type value, facilitating a different
48 : : //! pair of global-scope RNG wrappers (uniform and uniform_bits) with code
49 : : //! reuse. Note that uniform and uniform_bits wrappers must be global-scope as
50 : : //! they are used as external generators to TestU01. Templating them on the
51 : : //! id enables the compiler generate a different wrapper for a different RNG
52 : : //! facilitating simultaneous calls to any or all wrappers as they are unique
53 : : //! functions.
54 : : // *****************************************************************************
55 : : {
56 [ + + ]: 296 : for (const auto& r : g_inputdeck.get< tag::selected, tag::rng >()) {
57 : : using tk::ctr::RNGType;
58 : : using tk::ctr::raw;
59 : : #ifdef HAS_MKL
60 : : if (r == RNGType::MKL_MCG31)
61 : : addRNG< raw(RNGType::MKL_MCG31) >( r );
62 : : else if (r == RNGType::MKL_R250)
63 : : addRNG< raw(RNGType::MKL_R250) >( r );
64 : : else if (r == RNGType::MKL_MRG32K3A)
65 : : addRNG< raw(RNGType::MKL_MRG32K3A) >( r );
66 : : else if (r == RNGType::MKL_MCG59)
67 : : addRNG< raw(RNGType::MKL_MCG59) >( r );
68 : : else if (r == RNGType::MKL_WH)
69 : : addRNG< raw(RNGType::MKL_WH) >( r );
70 : : else if (r == RNGType::MKL_MT19937)
71 : : addRNG< raw(RNGType::MKL_MT19937) >( r );
72 : : else if (r == RNGType::MKL_MT2203)
73 : : addRNG< raw(RNGType::MKL_MT2203) >( r );
74 : : else if (r == RNGType::MKL_SFMT19937)
75 : : addRNG< raw(RNGType::MKL_SFMT19937) >( r );
76 : : else if (r == RNGType::MKL_SOBOL)
77 : : addRNG< raw(RNGType::MKL_SOBOL) >( r );
78 : : else if (r == RNGType::MKL_NIEDERR)
79 : : addRNG< raw(RNGType::MKL_NIEDERR) >( r );
80 : : //else if (r == RNGType::MKL_IABSTRACT)
81 : : // addRNG< raw(RNGType::MKL_IABSTRACT) >( r );
82 : : //else if (r == RNGType::MKL_DABSTRACT)
83 : : // addRNG< raw(RNGType::MKL_DABSTRACT) >( r );
84 : : //else if (r == RNGType::MKL_SABSTRACT)
85 : : // addRNG< raw(RNGType::MKL_SABSTRACT) >( r );
86 : : else if (r == RNGType::MKL_NONDETERM)
87 : : addRNG< raw(RNGType::MKL_NONDETERM) >( r );
88 : : else
89 : : #endif
90 : : #ifdef HAS_RNGSSE2
91 [ - + ]: 120 : if (r == RNGType::RNGSSE_GM19)
92 [ - - ]: 0 : addRNG< raw(RNGType::RNGSSE_GM19) >( r );
93 [ - + ]: 120 : else if (r == RNGType::RNGSSE_GM29)
94 [ - - ]: 0 : addRNG< raw(RNGType::RNGSSE_GM29) >( r );
95 [ + + ]: 120 : else if (r == RNGType::RNGSSE_GM31)
96 [ + - ]: 8 : addRNG< raw(RNGType::RNGSSE_GM31) >( r );
97 [ - + ]: 112 : else if (r == RNGType::RNGSSE_GM55)
98 [ - - ]: 0 : addRNG< raw(RNGType::RNGSSE_GM55) >( r );
99 [ - + ]: 112 : else if (r == RNGType::RNGSSE_GM61)
100 [ - - ]: 0 : addRNG< raw(RNGType::RNGSSE_GM61) >( r );
101 [ + + ]: 112 : else if (r == RNGType::RNGSSE_GQ581)
102 [ + - ]: 8 : addRNG< raw(RNGType::RNGSSE_GQ581) >( r );
103 [ - + ]: 104 : else if (r == RNGType::RNGSSE_GQ583)
104 [ - - ]: 0 : addRNG< raw(RNGType::RNGSSE_GQ583) >( r );
105 [ - + ]: 104 : else if (r == RNGType::RNGSSE_GQ584)
106 [ - - ]: 0 : addRNG< raw(RNGType::RNGSSE_GQ584) >( r );
107 [ - + ]: 104 : else if (r == RNGType::RNGSSE_MT19937)
108 [ - - ]: 0 : addRNG< raw(RNGType::RNGSSE_MT19937) >( r );
109 [ + + ]: 104 : else if (r == RNGType::RNGSSE_LFSR113)
110 [ + - ]: 8 : addRNG< raw(RNGType::RNGSSE_LFSR113) >( r );
111 [ + + ]: 96 : else if (r == RNGType::RNGSSE_MRG32K3A)
112 [ + - ]: 8 : addRNG< raw(RNGType::RNGSSE_MRG32K3A) >( r );
113 : : else
114 : : #endif
115 [ + + ]: 88 : if (r == RNGType::R123_THREEFRY)
116 [ + - ]: 44 : addRNG< raw(RNGType::R123_THREEFRY) >( r );
117 [ + - ]: 44 : else if (r == RNGType::R123_PHILOX)
118 [ + - ]: 44 : addRNG< raw(RNGType::R123_PHILOX) >( r );
119 : : }
120 : 176 : }
121 : :
122 : : template< tk::ctr::RawRNGType id >
123 : 120 : void TestU01Stack::addRNG( tk::ctr::RNGType r )
124 : : // *****************************************************************************
125 : : //! Create TestU01 RNG wrapper
126 : : //! \param[in] r RNG ID enum
127 : : // *****************************************************************************
128 : : {
129 : 240 : m_generator.emplace( r,
130 : : Gen01Ptr( createTestU01Gen<id>( tk::ctr::RNG().name(r) ) ) );
131 : 120 : }
132 : :
133 : : unif01_Gen*
134 : 272 : TestU01Stack::generator( tk::ctr::RNGType r ) const
135 : : // *****************************************************************************
136 : : //! Find TestU01 RNG wrapper based on RNG id
137 : : //! \param[in] r RNG ID enum
138 : : //! \return Raw function pointer to TestU01 statistical test
139 : : // *****************************************************************************
140 : : {
141 : : const auto& gen = m_generator.find( r );
142 [ - + ][ - - ]: 272 : if (gen == end(m_generator)) Throw( "RNG not found" );
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ]
143 : 272 : return gen->second.get();
144 : : }
145 : :
146 : : std::vector< double >
147 : 22 : TestU01Stack::BirthdaySpacings( unif01_Gen* gen, sres_Poisson* res,
148 : : const std::tuple<long, long, int, long, int, int>& xargs )
149 : : // *****************************************************************************
150 : : // Run Marsaglia's BirthdaySpacings test
151 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
152 : : //! \param[in] res Pointer to test results object
153 : : //! \param[in] xargs Test arguments
154 : : //! \return Vector p-values as a result of the statistical test
155 : : // *****************************************************************************
156 : : {
157 : : using std::get;
158 : :
159 : : fenv_t fe;
160 : 22 : feholdexcept( &fe );
161 : :
162 : 22 : smarsa_BirthdaySpacings( gen, res, get<0>(xargs), get<1>(xargs),
163 : : get<2>(xargs), get<3>(xargs), get<4>(xargs),
164 : : get<5>(xargs) );
165 : :
166 : 22 : feclearexcept( FE_UNDERFLOW );
167 : 22 : feupdateenv( &fe );
168 : :
169 : 22 : return { res->pVal2 };
170 : : }
171 : :
172 : : std::vector< double >
173 : 6 : TestU01Stack::Collision( unif01_Gen* gen, sknuth_Res2* res,
174 : : const std::tuple<long, long, int, long, int>& xargs )
175 : : // *****************************************************************************
176 : : // Run Knuth's Collision test
177 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
178 : : //! \param[in] res Pointer to test results object
179 : : //! \param[in] xargs Test arguments
180 : : //! \return Vector p-values as a result of the statistical test
181 : : // *****************************************************************************
182 : : {
183 : : using std::get;
184 : 6 : sknuth_Collision( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
185 : : get<3>(xargs), get<4>(xargs) );
186 : 6 : return { res->Pois->pVal2 };
187 : : }
188 : :
189 : : std::vector< double >
190 : 14 : TestU01Stack::Gap( unif01_Gen* gen, sres_Chi2* res,
191 : : const std::tuple<long, long, int, double, double>& xargs )
192 : : // *****************************************************************************
193 : : // Run Knuth's Gap test
194 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
195 : : //! \param[in] res Pointer to test results object
196 : : //! \param[in] xargs Test arguments
197 : : //! \return Vector p-values as a result of the statistical test
198 : : // *****************************************************************************
199 : : {
200 : : using std::get;
201 : 14 : sknuth_Gap( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
202 : : get<3>(xargs), get<4>(xargs) );
203 : 14 : return { res->pVal2[gofw_Mean] };
204 : : }
205 : :
206 : : std::vector< double >
207 : 14 : TestU01Stack::SimplePoker( unif01_Gen* gen, sres_Chi2* res,
208 : : const std::tuple<long, long, int, int, int>& xargs )
209 : : // *****************************************************************************
210 : : // Run Knuth's Simplified Poker test
211 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
212 : : //! \param[in] res Pointer to test results object
213 : : //! \param[in] xargs Test arguments
214 : : //! \return Vector p-values as a result of the statistical test
215 : : // *****************************************************************************
216 : : {
217 : : using std::get;
218 : 14 : sknuth_SimpPoker( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
219 : : get<3>(xargs), get<4>(xargs) );
220 : 14 : return { res->pVal2[gofw_Mean] };
221 : : }
222 : :
223 : : std::vector< double >
224 : 14 : TestU01Stack::CouponCollector( unif01_Gen* gen, sres_Chi2* res,
225 : : const std::tuple<long, long, int, int>& xargs )
226 : : // *****************************************************************************
227 : : // Run Knuth's Coupon Collector test
228 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
229 : : //! \param[in] res Pointer to test results object
230 : : //! \param[in] xargs Test arguments
231 : : //! \return Vector p-values as a result of the statistical test
232 : : // *****************************************************************************
233 : : {
234 : : using std::get;
235 : 14 : sknuth_CouponCollector( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
236 : : get<3>(xargs) );
237 : 14 : return { res->pVal2[gofw_Mean] };
238 : : }
239 : :
240 : : std::vector< double >
241 : 14 : TestU01Stack::MaxOft( unif01_Gen* gen, sknuth_Res1* res,
242 : : const std::tuple<long, long, int, int, int, int, int>& xargs )
243 : : // *****************************************************************************
244 : : // Run Knuth's Maximum-of-t test
245 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
246 : : //! \param[in] res Pointer to test results object
247 : : //! \param[in] xargs Test arguments
248 : : //! \return Vector p-values as a result of the statistical test
249 : : // *****************************************************************************
250 : : {
251 : : using std::get;
252 : 14 : sknuth_MaxOft( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
253 : : get<3>(xargs), get<4>(xargs) );
254 : 14 : return { res->Chi->pVal2[get<5>(xargs)],
255 : 14 : res->Bas->pVal2[get<6>(xargs)] };
256 : : }
257 : :
258 : : std::vector< double >
259 : 16 : TestU01Stack::WeightDistrib( unif01_Gen* gen, sres_Chi2* res,
260 : : const std::tuple<long, long, int, long, double, double>& xargs )
261 : : // *****************************************************************************
262 : : // Run Matsumoto's Weight Distribution test
263 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
264 : : //! \param[in] res Pointer to test results object
265 : : //! \param[in] xargs Test arguments
266 : : //! \return Vector p-values as a result of the statistical test
267 : : // *****************************************************************************
268 : : {
269 : : using std::get;
270 : 16 : svaria_WeightDistrib( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
271 : : get<3>(xargs), get<4>(xargs), get<5>(xargs) );
272 : 16 : return { res->pVal2[gofw_Mean] };
273 : : }
274 : :
275 : : std::vector< double >
276 : 18 : TestU01Stack::MatrixRank( unif01_Gen* gen, sres_Chi2* res,
277 : : const std::tuple<long, long, int, int, int, int>& xargs )
278 : : // *****************************************************************************
279 : : // Run Marsaglia's Matrix Rank test
280 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
281 : : //! \param[in] res Pointer to test results object
282 : : //! \param[in] xargs Test arguments
283 : : //! \return Vector p-values as a result of the statistical test
284 : : // *****************************************************************************
285 : : {
286 : : using std::get;
287 : :
288 : : fenv_t fe;
289 : 18 : feholdexcept( &fe );
290 : :
291 : 18 : smarsa_MatrixRank( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
292 : : get<3>(xargs), get<4>(xargs), get<5>(xargs) );
293 : :
294 : 18 : feclearexcept( FE_UNDERFLOW );
295 : 18 : feupdateenv( &fe );
296 : :
297 : 18 : return { res->pVal2[gofw_Mean] };
298 : : }
299 : :
300 : : std::vector< double >
301 : 18 : TestU01Stack::HammingIndep( unif01_Gen* gen, sstring_Res* res,
302 : : const std::tuple<long, long, int, int, int, int>& xargs )
303 : : // *****************************************************************************
304 : : // Run L'Ecuyer's Hamming Independence test
305 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
306 : : //! \param[in] res Pointer to test results object
307 : : //! \param[in] xargs Test arguments
308 : : //! \return Vector p-values as a result of the statistical test
309 : : // *****************************************************************************
310 : : {
311 : : using std::get;
312 : 18 : sstring_HammingIndep( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
313 : : get<3>(xargs), get<4>(xargs), get<5>(xargs) );
314 : 18 : return { res->Bas->pVal2[gofw_Mean] };
315 : : }
316 : :
317 : : std::vector< double >
318 : 18 : TestU01Stack::RandomWalk1( unif01_Gen* gen, swalk_Res* res,
319 : : const std::tuple<long, long, int, int, long, long>& xargs )
320 : : // *****************************************************************************
321 : : // Run Random Walk 1 test
322 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
323 : : //! \param[in] res Pointer to test results object
324 : : //! \param[in] xargs Test arguments
325 : : //! \return Vector p-values as a result of the statistical test
326 : : // *****************************************************************************
327 : : {
328 : : using std::get;
329 : 18 : swalk_RandomWalk1( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
330 : : get<3>(xargs), get<4>(xargs), get<5>(xargs) );
331 : 18 : return { res->H[0]->pVal2[gofw_Mean],
332 : 18 : res->M[0]->pVal2[gofw_Mean],
333 : 18 : res->J[0]->pVal2[gofw_Mean],
334 : 18 : res->R[0]->pVal2[gofw_Mean],
335 : 18 : res->C[0]->pVal2[gofw_Mean] };
336 : : }
337 : :
338 : : std::vector< double >
339 : 4 : TestU01Stack::SerialOver( unif01_Gen* gen, sres_Basic* res,
340 : : const std::tuple<long, long, int, long, int>& xargs )
341 : : // *****************************************************************************
342 : : // Run Marsaglia's Serial Over test, t = 2
343 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
344 : : //! \param[in] res Pointer to test results object
345 : : //! \param[in] xargs Test arguments
346 : : //! \return Vector p-values as a result of the statistical test
347 : : // *****************************************************************************
348 : : {
349 : : using std::get;
350 : 4 : smarsa_SerialOver( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
351 : : get<3>(xargs), get<4>(xargs) );
352 : 4 : return { res->pVal2[gofw_Mean] };
353 : : }
354 : :
355 : : std::vector< double >
356 : 19 : TestU01Stack::CollisionOver( unif01_Gen* gen, smarsa_Res* res,
357 : : const std::tuple<long, long, int, long, int>& xargs )
358 : : // *****************************************************************************
359 : : // Run Marsaglia's Serial Over test, t = 2
360 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
361 : : //! \param[in] res Pointer to test results object
362 : : //! \param[in] xargs Test arguments
363 : : //! \return Vector p-values as a result of the statistical test
364 : : // *****************************************************************************
365 : : {
366 : : using std::get;
367 : 19 : smarsa_CollisionOver( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
368 : : get<3>(xargs), get<4>(xargs) );
369 : 19 : return { res->Pois->pVal2 };
370 : : }
371 : :
372 : : std::vector< double >
373 : 7 : TestU01Stack::ClosePairs( unif01_Gen* gen, snpair_Res* res,
374 : : const std::tuple<long, long, int, int, int, int, int>& xargs )
375 : : // *****************************************************************************
376 : : // Run the close-pairs test, t = 2
377 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
378 : : //! \param[in] res Pointer to test results object
379 : : //! \param[in] xargs Test arguments
380 : : //! \return Vector p-values as a result of the statistical test
381 : : // *****************************************************************************
382 : : {
383 : : using std::get;
384 : 7 : snpair_ClosePairs( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
385 : : get<3>(xargs), get<4>(xargs), get<5>(xargs) );
386 [ + + ]: 7 : if (get<6>(xargs)) {
387 : 6 : return { res->pVal[snpair_NP],
388 : 6 : res->pVal[snpair_mNP],
389 : 6 : res->pVal[snpair_mNP1],
390 : 6 : res->pVal[snpair_mNP2],
391 : 6 : res->pVal[snpair_NJumps],
392 : 6 : res->pVal[snpair_mNP2S] };
393 : : } else {
394 : 1 : return { res->pVal[snpair_NP],
395 : 1 : res->pVal[snpair_mNP],
396 : 1 : res->pVal[snpair_mNP1],
397 : 1 : res->pVal[snpair_mNP2],
398 : 1 : res->pVal[snpair_NJumps] };
399 : : }
400 : : }
401 : :
402 : : std::vector< double >
403 : 2 : TestU01Stack::ClosePairsBitMatch( unif01_Gen* gen, snpair_Res* res,
404 : : const std::tuple<long, long, int, int>& xargs )
405 : : // *****************************************************************************
406 : : // Run the close-pairs test using bit match distance, t = 2
407 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
408 : : //! \param[in] res Pointer to test results object
409 : : //! \param[in] xargs Test arguments
410 : : //! \return Vector p-values as a result of the statistical test
411 : : // *****************************************************************************
412 : : {
413 : : using std::get;
414 : 2 : snpair_ClosePairsBitMatch( gen, res, get<0>(xargs), get<1>(xargs),
415 : : get<2>(xargs), get<3>(xargs) );
416 : 2 : return { res->pVal[snpair_BM] };
417 : : }
418 : :
419 : : std::vector< double >
420 : 4 : TestU01Stack::Run( unif01_Gen* gen, sres_Chi2* res,
421 : : const std::tuple<long, long, int, int>& xargs )
422 : : // *****************************************************************************
423 : : // Run Knuth's Run test
424 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
425 : : //! \param[in] res Pointer to test results object
426 : : //! \param[in] xargs Test arguments
427 : : //! \return Vector p-values as a result of the statistical test
428 : : // *****************************************************************************
429 : : {
430 : : using std::get;
431 : 4 : sknuth_Run( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
432 : : get<3>(xargs) );
433 : 4 : return { res->pVal2[gofw_Mean] };
434 : : }
435 : :
436 : : std::vector< double >
437 : 6 : TestU01Stack::Permutation( unif01_Gen* gen, sres_Chi2* res,
438 : : const std::tuple<long, long, int, int>& xargs )
439 : : // *****************************************************************************
440 : : // Run Knuth's Permutation test
441 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
442 : : //! \param[in] res Pointer to test results object
443 : : //! \param[in] xargs Test arguments
444 : : //! \return Vector p-values as a result of the statistical test
445 : : // *****************************************************************************
446 : : {
447 : : using std::get;
448 : 6 : sknuth_Permutation( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
449 : : get<3>(xargs) );
450 : 6 : return { res->pVal2[gofw_Mean] };
451 : : }
452 : :
453 : : std::vector< double >
454 : 4 : TestU01Stack::CollisionPermut( unif01_Gen* gen, sknuth_Res2* res,
455 : : const std::tuple<long, long, int, int>& xargs )
456 : : // *****************************************************************************
457 : : // Run Knuth's Collision test with permutations
458 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
459 : : //! \param[in] res Pointer to test results object
460 : : //! \param[in] xargs Test arguments
461 : : //! \return Vector p-values as a result of the statistical test
462 : : // *****************************************************************************
463 : : {
464 : : using std::get;
465 : 4 : sknuth_CollisionPermut( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
466 : : get<3>(xargs) );
467 : 4 : return { res->Pois->pVal2 };
468 : : }
469 : :
470 : : std::vector< double >
471 : 5 : TestU01Stack::SampleProd( unif01_Gen* gen, sres_Basic* res,
472 : : const std::tuple<long, long, int, int>& xargs )
473 : : // *****************************************************************************
474 : : // Run Sample Products test
475 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
476 : : //! \param[in] res Pointer to test results object
477 : : //! \param[in] xargs Test arguments
478 : : //! \return Vector p-values as a result of the statistical test
479 : : // *****************************************************************************
480 : : {
481 : : using std::get;
482 : 5 : svaria_SampleProd( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
483 : : get<3>(xargs) );
484 : 5 : return { res->pVal2[gofw_Mean] };
485 : : }
486 : :
487 : : std::vector< double >
488 : 3 : TestU01Stack::SampleMean( unif01_Gen* gen, sres_Basic* res,
489 : : const std::tuple<long, long, int>& xargs )
490 : : // *****************************************************************************
491 : : // Run Sample Mean test
492 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
493 : : //! \param[in] res Pointer to test results object
494 : : //! \param[in] xargs Test arguments
495 : : //! \return Vector p-values as a result of the statistical test
496 : : // *****************************************************************************
497 : : {
498 : : using std::get;
499 : 3 : svaria_SampleMean( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs) );
500 : 3 : return { res->pVal2[gofw_AD] };
501 : : }
502 : :
503 : : std::vector< double >
504 : 3 : TestU01Stack::SampleCorr( unif01_Gen* gen, sres_Basic* res,
505 : : const std::tuple<long, long, int, int>& xargs )
506 : : // *****************************************************************************
507 : : // Run Sample Autocorrelation test
508 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
509 : : //! \param[in] res Pointer to test results object
510 : : //! \param[in] xargs Test arguments
511 : : //! \return Vector p-values as a result of the statistical test
512 : : // *****************************************************************************
513 : : {
514 : : using std::get;
515 : 3 : svaria_SampleCorr( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
516 : : get<3>(xargs) );
517 : 3 : return { res->pVal2[gofw_Mean] };
518 : : }
519 : :
520 : : std::vector< double >
521 : 5 : TestU01Stack::AppearanceSpacings( unif01_Gen* gen, sres_Basic* res,
522 : : const std::tuple<long, long, long, int, int, int>& xargs )
523 : : // *****************************************************************************
524 : : // Run Maurer's "universal" test
525 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
526 : : //! \param[in] res Pointer to test results object
527 : : //! \param[in] xargs Test arguments
528 : : //! \return Vector p-values as a result of the statistical test
529 : : // *****************************************************************************
530 : : {
531 : : using std::get;
532 : 5 : svaria_AppearanceSpacings( gen, res, get<0>(xargs), get<1>(xargs),
533 : : get<2>(xargs), get<3>(xargs), get<4>(xargs),
534 : : get<5>(xargs) );
535 : 5 : return { res->pVal2[gofw_Mean] };
536 : : }
537 : :
538 : : std::vector< double >
539 : 2 : TestU01Stack::SumCollector( unif01_Gen* gen, sres_Chi2* res,
540 : : const std::tuple<long, long, int, double>& xargs )
541 : : // *****************************************************************************
542 : : // Run Sum Collector test
543 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
544 : : //! \param[in] res Pointer to test results object
545 : : //! \param[in] xargs Test arguments
546 : : //! \return Vector p-values as a result of the statistical test
547 : : // *****************************************************************************
548 : : {
549 : : using std::get;
550 : 2 : svaria_SumCollector( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
551 : : get<3>(xargs) );
552 : 2 : return { res->pVal2[gofw_Mean] };
553 : : }
554 : :
555 : : std::vector< double >
556 : 2 : TestU01Stack::Savir2( unif01_Gen* gen, sres_Chi2* res,
557 : : const std::tuple<long, long, int, long, int>& xargs )
558 : : // *****************************************************************************
559 : : // Run Marsaglia's modified Savir test
560 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
561 : : //! \param[in] res Pointer to test results object
562 : : //! \param[in] xargs Test arguments
563 : : //! \return Vector p-values as a result of the statistical test
564 : : // *****************************************************************************
565 : : {
566 : : using std::get;
567 : 2 : smarsa_Savir2( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
568 : : get<3>(xargs), get<4>(xargs) );
569 : 2 : return { res->pVal2[gofw_Mean] };
570 : : }
571 : :
572 : : std::vector< double >
573 : 3 : TestU01Stack::GCD( unif01_Gen* gen, smarsa_Res2* res,
574 : : const std::tuple<long, long, int, int>& xargs )
575 : : // *****************************************************************************
576 : : // Run Marsaglia's greatest common divisor test
577 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
578 : : //! \param[in] res Pointer to test results object
579 : : //! \param[in] xargs Test arguments
580 : : //! \return Vector p-values as a result of the statistical test
581 : : // *****************************************************************************
582 : : {
583 : : using std::get;
584 : 3 : smarsa_GCD( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
585 : : get<3>(xargs) );
586 : 3 : return { res->GCD->pVal2[gofw_Mean] };
587 : : }
588 : :
589 : : std::vector< double >
590 : 4 : TestU01Stack::LinearComp( unif01_Gen* gen, scomp_Res* res,
591 : : const std::tuple<long, long, int, int>& xargs )
592 : : // *****************************************************************************
593 : : // Run Linear Complexity test
594 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
595 : : //! \param[in] res Pointer to test results object
596 : : //! \param[in] xargs Test arguments
597 : : //! \return Vector p-values as a result of the statistical test
598 : : // *****************************************************************************
599 : : {
600 : : using std::get;
601 : 4 : scomp_LinearComp( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
602 : : get<3>(xargs) );
603 : 4 : return { res->JumpNum->pVal2[gofw_Mean],
604 : 4 : res->JumpSize->pVal2[gofw_Mean] };
605 : : }
606 : :
607 : : std::vector< double >
608 : 3 : TestU01Stack::LempelZiv( unif01_Gen* gen, sres_Basic* res,
609 : : const std::tuple<long, int, int, int>& xargs )
610 : : // *****************************************************************************
611 : : // Run Lempel-Ziv Compressibility test
612 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
613 : : //! \param[in] res Pointer to test results object
614 : : //! \param[in] xargs Test arguments
615 : : //! \return Vector p-values as a result of the statistical test
616 : : // *****************************************************************************
617 : : {
618 : : using std::get;
619 : 3 : scomp_LempelZiv( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
620 : : get<3>(xargs) );
621 : 3 : return { res->pVal2[gofw_Sum] };
622 : : }
623 : :
624 : : std::vector< double >
625 : 4 : TestU01Stack::Fourier3( unif01_Gen* gen, sspectral_Res* res,
626 : : const std::tuple<long, int, int, int>& xargs )
627 : : // *****************************************************************************
628 : : // Run Fourier3 test
629 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
630 : : //! \param[in] res Pointer to test results object
631 : : //! \param[in] xargs Test arguments
632 : : //! \return Vector p-values as a result of the statistical test
633 : : // *****************************************************************************
634 : : {
635 : : using std::get;
636 : 4 : sspectral_Fourier3( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
637 : : get<3>(xargs) );
638 : 4 : return { res->Bas->pVal2[gofw_AD] };
639 : : }
640 : :
641 : : std::vector< double >
642 : 4 : TestU01Stack::LongestHeadRun( unif01_Gen* gen, sstring_Res2* res,
643 : : const std::tuple<long, long, int, int, long>& xargs )
644 : : // *****************************************************************************
645 : : // Run Longest Head Run test
646 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
647 : : //! \param[in] res Pointer to test results object
648 : : //! \param[in] xargs Test arguments
649 : : //! \return Vector p-values as a result of the statistical test
650 : : // *****************************************************************************
651 : : {
652 : : using std::get;
653 : 4 : sstring_LongestHeadRun( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
654 : : get<3>(xargs), get<4>(xargs) );
655 : 4 : return { res->Chi->pVal2[gofw_Mean],
656 : 4 : res->Disc->pVal2 };
657 : : }
658 : :
659 : : std::vector< double >
660 : 4 : TestU01Stack::PeriodsInStrings( unif01_Gen* gen, sres_Chi2* res,
661 : : const std::tuple<long, long, int, int>& xargs )
662 : : // *****************************************************************************
663 : : // Run Periods In Strings test
664 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
665 : : //! \param[in] res Pointer to test results object
666 : : //! \param[in] xargs Test arguments
667 : : //! \return Vector p-values as a result of the statistical test
668 : : // *****************************************************************************
669 : : {
670 : : using std::get;
671 : 4 : sstring_PeriodsInStrings( gen, res, get<0>(xargs), get<1>(xargs),
672 : : get<2>(xargs), get<3>(xargs) );
673 : 4 : return { res->pVal2[gofw_Mean] };
674 : : }
675 : :
676 : : std::vector< double >
677 : 4 : TestU01Stack::HammingWeight2( unif01_Gen* gen, sres_Basic* res,
678 : : const std::tuple<long, long, int, int, long>& xargs )
679 : : // *****************************************************************************
680 : : // Run Hamming Weight 2 test
681 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
682 : : //! \param[in] res Pointer to test results object
683 : : //! \param[in] xargs Test arguments
684 : : //! \return Vector p-values as a result of the statistical test
685 : : // *****************************************************************************
686 : : {
687 : : using std::get;
688 : 4 : sstring_HammingWeight2( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
689 : : get<3>(xargs), get<4>(xargs) );
690 : 4 : return { res->pVal2[gofw_Sum] };
691 : : }
692 : :
693 : : std::vector< double >
694 : 6 : TestU01Stack::HammingCorr( unif01_Gen* gen, sstring_Res* res,
695 : : const std::tuple<long, long, int, int, int>& xargs )
696 : : // *****************************************************************************
697 : : // Run Hamming Weight Correlation test
698 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
699 : : //! \param[in] res Pointer to test results object
700 : : //! \param[in] xargs Test arguments
701 : : //! \return Vector p-values as a result of the statistical test
702 : : // *****************************************************************************
703 : : {
704 : : using std::get;
705 : 6 : sstring_HammingCorr( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
706 : : get<3>(xargs), get<4>(xargs) );
707 : 6 : return { res->Bas->pVal2[gofw_Mean] };
708 : : }
709 : :
710 : : std::vector< double >
711 : 4 : TestU01Stack::StringRun( unif01_Gen* gen, sstring_Res3* res,
712 : : const std::tuple<long, long, int, int>& xargs )
713 : : // *****************************************************************************
714 : : // Run String Run test
715 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
716 : : //! \param[in] res Pointer to test results object
717 : : //! \param[in] xargs Test arguments
718 : : //! \return Vector p-values as a result of the statistical test
719 : : // *****************************************************************************
720 : : {
721 : : using std::get;
722 : 4 : sstring_Run( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
723 : : get<3>(xargs) );
724 : 4 : return { res->NRuns->pVal2[gofw_Mean],
725 : 4 : res->NBits->pVal2[gofw_Mean] };
726 : : }
727 : :
728 : : std::vector< double >
729 : 8 : TestU01Stack::AutoCorr( unif01_Gen* gen, sres_Basic* res,
730 : : const std::tuple<long, long, int, int, int>& xargs )
731 : : // *****************************************************************************
732 : : // Run Autocorrelation test
733 : : //! \param[in] gen Raw function pointer to TestU01 statistical test
734 : : //! \param[in] res Pointer to test results object
735 : : //! \param[in] xargs Test arguments
736 : : //! \return Vector p-values as a result of the statistical test
737 : : // *****************************************************************************
738 : : {
739 : : using std::get;
740 : 8 : sstring_AutoCor( gen, res, get<0>(xargs), get<1>(xargs), get<2>(xargs),
741 : : get<3>(xargs), get<4>(xargs) );
742 : 8 : return { res->pVal2[gofw_Sum] };
743 : : }
|
