RandomLib  1.10
 All Classes Namespaces Files Functions Variables Typedefs Enumerator Friends Macros Pages
RandomCoverage.cpp
Go to the documentation of this file.
1 /**
2  * \file RandomCoverage.cpp
3  * \brief Coverage test for %RandomLib
4  *
5  * Compile/link with, e.g.,\n
6  * g++ -I../include -O2 -funroll-loops
7  * -o RandomCoverage RandomCoverage.cpp ../src/Random.cpp\n
8  * ./RandomCoverage
9  *
10  * This executes nearly all of the public functions in %RandomLib. This is
11  * important, since it allows the compiler to check the code which appears in
12  * header files. It also shows how templated functions can be invoked.
13  *
14  * Copyright (c) Charles Karney (2006-2012) <charles@karney.com> and licensed
15  * under the MIT/X11 License. For more information, see
16  * http://randomlib.sourceforge.net/
17  **********************************************************************/
18 
19 #include <iostream>
20 #include <vector>
21 #include <string>
22 #include <sstream>
23 #include <RandomLib/Random.hpp>
24 #include <RandomLib/NormalDistribution.hpp>
25 #include <RandomLib/ExponentialDistribution.hpp>
26 #include <RandomLib/RandomSelect.hpp>
27 #include <RandomLib/LeadingZeros.hpp>
28 #include <RandomLib/ExponentialProb.hpp>
29 #include <RandomLib/RandomNumber.hpp>
30 #include <RandomLib/UniformInteger.hpp>
31 #include <RandomLib/ExactExponential.hpp>
32 #include <RandomLib/ExactNormal.hpp>
33 #include <RandomLib/DiscreteNormal.hpp>
34 #include <RandomLib/DiscreteNormalAlt.hpp>
35 #include <RandomLib/ExactPower.hpp>
36 #include <RandomLib/InversePiProb.hpp>
37 #include <RandomLib/InverseEProb.hpp>
38 
39 #define repeat for (int i = 0; i < 1000; ++i)
40 
41 void coverage32() {
42  typedef RandomLib::SRandom32 Random;
43  {
44  // Setting and examing the seed + seed management
45  std::vector<unsigned long> v(Random::SeedVector());
46  unsigned long w = Random::SeedWord();
47  std::string s(Random::VectorToString(v));
48  { Random r(v); }
49  { Random r(v.begin(), v.end()); }
50  int a[] = {1, 2, 3, 4};
51  { Random r(a, a + 4); }
52  { Random r(w); }
53  { Random r(s); }
54  { Random r; }
55  Random r(0);
56  r.Reseed(v);
57  r.Reseed(v.begin(), v.end());
58  r.Reseed(w);
59  r.Reseed(s);
60  r.Reseed();
61  v = r.Seed();
62  s = r.SeedString();
63  r.Reseed(Random::VectorToString(v));
64  r.Reseed(Random::StringToVector(s));
65  }
66  Random r;
67  {
68  // Functions returning random integers
69  repeat r();
70  repeat r.Ran();
71  repeat r.Ran32();
72  repeat r.Ran64();
73  repeat r(52);
74  repeat r.Integer<signed char, 3>();
75  repeat r.Integer<unsigned char, 3>();
76  repeat r.Integer<signed short, 3>();
77  repeat r.Integer<3>();
78  repeat r.Integer();
79  repeat r.Integer<signed short>();
80  repeat r.Integer<signed short>(52);
81  repeat r.IntegerC<signed short>(51);
82  repeat r.IntegerC<signed short>(1,52);
83  repeat r.Integer(6u);
84  repeat r.IntegerC(5u);
85  repeat r.IntegerC(1u,6u);
86  repeat r();
87  repeat r(52u);
88  }
89  {
90  // Functions returning random reals
91  repeat { r.Fixed <float, 16 >(); r.Fixed <float>(); r.Fixed (); }
92  repeat { r.FixedU<float, 16 >(); r.FixedU<float>(); r.FixedU(); }
93  repeat { r.FixedN<float, 16 >(); r.FixedN<float>(); r.FixedN(); }
94  repeat { r.FixedW<float, 16 >(); r.FixedW<float>(); r.FixedW(); }
95  repeat { r.FixedS<float, 16 >(); r.FixedS<float>(); r.FixedS(); }
96  repeat { r.FixedO<float, 16 >(); r.FixedO<float>(); r.FixedO(); }
97  repeat { r.Float <float, 4, 2>(); r.Float <float>(); r.Float (); }
98  repeat { r.FloatU<float, 4, 2>(); r.FloatU<float>(); r.FloatU(); }
99  repeat { r.FloatN<float, 4, 2>(); r.FloatN<float>(); r.FloatN(); }
100  repeat { r.FloatW<float, 4, 2>(); r.FloatW<float>(); r.FloatW(); }
101  repeat { r.Real<float>(); r.Real(); }
102  }
103  {
104  // Functions returning other random results
105  repeat r.Boolean();
106  repeat r.Prob(0.5f);
107  repeat r.Prob(2.3, 7.0);
108  repeat r.Prob(23, 70);
109  repeat r.Bits< 5>();
110  repeat r.Bits<64>();
111  }
112  {
113  // Normal distribution
114  RandomLib::NormalDistribution<float> nf;
115  RandomLib::NormalDistribution<> nd;
116  repeat nf(r);
117  repeat nd(r, 1.0, 2.0);
118  }
119  {
120  // Exponention distribution
121  RandomLib::ExponentialDistribution<float> ef;
122  RandomLib::ExponentialDistribution<> ed;
123  repeat ef(r);
124  repeat ed(r, 2.0);
125  }
126  {
127  // Discrete probabilities
128  unsigned w[] = { 0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1 };
129  std::vector<int> wi(13);
130  std::vector<float> wf(13);
131  for (int i = 0; i < 13; ++i) {
132  wi[i] = int(w[i]);
133  wf[i] = float(w[i]);
134  }
135  { RandomLib::RandomSelect<unsigned> sel; }
136  { RandomLib::RandomSelect<unsigned> sel(w, w + 13); }
137  { RandomLib::RandomSelect<unsigned> sel(wi.begin(), wi.end()); }
138  { RandomLib::RandomSelect<unsigned> sel(wi); }
139  { RandomLib::RandomSelect<> sel; }
140  { RandomLib::RandomSelect<> sel(w, w + 13); }
141  { RandomLib::RandomSelect<> sel(wi); }
142  { RandomLib::RandomSelect<> sel(wf.begin(), wf.end()); }
143  { RandomLib::RandomSelect<> sel(wf); }
144  {
145  RandomLib::RandomSelect<unsigned> sel;
146  sel.Init(w, w + 13);
147  sel.Init(wi.begin(), wi.end());
148  sel.Init(wi);
149  repeat sel(r);
150  sel.TotalWeight();
151  sel.MaxWeight();
152  sel.Weight(3);
153  sel.Choices();
154  }
155  {
156  RandomLib::RandomSelect<> sel;
157  sel.Init(w, w + 13);
158  sel.Init(wi.begin(), wi.end());
159  sel.Init(wi);
160  sel.Init(wf);
161  repeat sel(r);
162  sel.TotalWeight();
163  sel.MaxWeight();
164  sel.Weight(3);
165  sel.Choices();
166  }
167  // Other distributions
168  { RandomLib::LeadingZeros lz; repeat lz(r); }
169  { RandomLib::ExponentialProb ep; repeat ep(r, 1.5f); }
170  {
171  // Infinite precision random numbers
172  {
173  RandomLib::RandomNumber<1> n;
174  n.Init();
175  n.Digit(r, 10);
176  n.RawDigit(4);
177  n.AddInteger(-2);
178  n.Negate();
179  n.Sign();
180  n.Floor();
181  n.Ceiling();
182  n.Size();
183  n.Range();
184  n.Fraction<float>(r);
185  n.Value<double>(r);
186  RandomLib::RandomNumber<1> p;
187  n.LessThan(r, p);
188  std::ostringstream os;
189  os << n;
190  }
191  {
192  RandomLib::RandomNumber<32> n;
193  n.Init();
194  n.Digit(r, 10);
195  n.RawDigit(4);
196  n.AddInteger(-2);
197  n.Negate();
198  n.Sign();
199  n.Floor();
200  n.Ceiling();
201  n.Size();
202  n.Range();
203  n.Fraction<float>(r);
204  n.Value<double>(r);
205  RandomLib::RandomNumber<32> p;
206  n.LessThan(r, p);
207  std::ostringstream os;
208  os << n;
209  }
210  {
211  if (RandomLib::UniformInteger<char, 4>::Check(37, 7)) {
212  RandomLib::UniformInteger<char, 4> u(r,37);
213  u.Min();
214  u.Max();
215  u.Entropy();
216  u.Add(3);
217  u.LessThan(r, 4, 1);
218  u.LessThanEqual(r, 4, 1);
219  u.GreaterThan(r, 60, 7);
220  u.GreaterThanEqual(r, 60, 7);
221  u.Negate();
222  std::ostringstream os;
223  os << u;
224  os << " " << u(r);
225  }
226  }
227  {
228  RandomLib::UniformInteger<short, 4> u(r,37);
229  u.Min();
230  u.Max();
231  u.Entropy();
232  u.Add(3);
233  u.LessThan(r, 4, 1);
234  u.LessThanEqual(r, 4, 1);
235  u.GreaterThan(r, 60, 7);
236  u.GreaterThanEqual(r, 60, 7);
237  u.Negate();
238  std::ostringstream os;
239  os << u;
240  os << " " << u(r);
241  }
242  {
243  RandomLib::UniformInteger<int, 4> u(r,37);
244  u.Min();
245  u.Max();
246  u.Entropy();
247  u.Add(3);
248  u.LessThan(r, 4, 1);
249  u.LessThanEqual(r, 4, 1);
250  u.GreaterThan(r, 60, 7);
251  u.GreaterThanEqual(r, 60, 7);
252  u.Negate();
253  std::ostringstream os;
254  os << u;
255  os << " " << u(r);
256  }
257  {
258  RandomLib::UniformInteger<long long, 32> u(r,37);
259  u.Min();
260  u.Max();
261  u.Entropy();
262  u.Add(3);
263  u.LessThan(r, 4, 1);
264  u.LessThanEqual(r, 4, 1);
265  u.GreaterThan(r, 60, 7);
266  u.GreaterThanEqual(r, 60, 7);
267  u.Negate();
268  std::ostringstream os;
269  os << u;
270  os << " " << u(r);
271  }
272  // Exact distributions
273  { RandomLib::ExactExponential< 1> ed; repeat ed(r).Value<float >(r); }
274  { RandomLib::ExactExponential<32> ed; repeat ed(r).Value<double>(r); }
275  { RandomLib::ExactNormal< 1> ed; repeat ed(r).Value<float >(r); }
276  { RandomLib::ExactNormal<32> ed; repeat ed(r).Value<double>(r); }
277  { RandomLib::ExactPower< 1> pd; repeat pd(r,2).Value<float >(r); }
278  { RandomLib::ExactPower<32> pd; repeat pd(r,3).Value<double>(r); }
279  { RandomLib::DiscreteNormal<short> pd(7); repeat pd(r); }
280  { RandomLib::DiscreteNormal<int> pd(7,1,1,2); repeat pd(r); }
281  { RandomLib::DiscreteNormal<long> pd(7,1,1,2); repeat pd(r); }
282  { RandomLib::DiscreteNormal<long long> pd(7); repeat pd(r); }
283  { RandomLib::DiscreteNormalAlt<short,1> pd(7); repeat pd(r)(r); }
284  { RandomLib::DiscreteNormalAlt<int,8> pd(7); repeat pd(r)(r); }
285  { RandomLib::DiscreteNormalAlt<long,28> pd(7); repeat pd(r)(r); }
286  { RandomLib::DiscreteNormalAlt<long long,32> pd(7); repeat pd(r)(r); }
287  { RandomLib::InversePiProb pd; repeat pd(r); }
288  { RandomLib::InverseEProb pd; repeat pd(r); }
289  }
290  }
291  {
292  // Setting position in sequence
293  r.Count();
294  r.StepCount(1000);
295  r.Reset();
296  r.SetCount(10000);
297  r.SetStride(10,1);
298  r.SetStride(5);
299  r.GetStride();
300  r.SetStride();
301  }
302  {
303  // Other
304  Random s(r);
305  s = Random::Global;
306  void(s == r);
307  void(s != s);
308  r.swap(s);
309  std::swap(r, s);
310  }
311 }
312 
313 void coverage64() {
314  typedef RandomLib::SRandom64 Random;
315  {
316  // Setting and examing the seed + seed management
317  std::vector<unsigned long> v(Random::SeedVector());
318  unsigned long w = Random::SeedWord();
319  std::string s(Random::VectorToString(v));
320  { Random r(v); }
321  { Random r(v.begin(), v.end()); }
322  int a[] = {1, 2, 3, 4};
323  { Random r(a, a + 4); }
324  { Random r(w); }
325  { Random r(s); }
326  { Random r; }
327  Random r(0);
328  r.Reseed(v);
329  r.Reseed(v.begin(), v.end());
330  r.Reseed(w);
331  r.Reseed(s);
332  r.Reseed();
333  v = r.Seed();
334  s = r.SeedString();
335  r.Reseed(Random::VectorToString(v));
336  r.Reseed(Random::StringToVector(s));
337  }
338  Random r;
339  {
340  // Functions returning random integers
341  repeat r();
342  repeat r.Ran();
343  repeat r.Ran32();
344  repeat r.Ran64();
345  repeat r(52);
346  repeat r.Integer<signed char, 3>();
347  repeat r.Integer<unsigned char, 3>();
348  repeat r.Integer<signed short, 3>();
349  repeat r.Integer<3>();
350  repeat r.Integer();
351  repeat r.Integer<signed short>();
352  repeat r.Integer<signed short>(52);
353  repeat r.IntegerC<signed short>(51);
354  repeat r.IntegerC<signed short>(1,52);
355  repeat r.Integer(6u);
356  repeat r.IntegerC(5u);
357  repeat r.IntegerC(1u,6u);
358  repeat r();
359  repeat r(52u);
360  }
361  {
362  // Functions returning random reals
363  repeat { r.Fixed <float, 16 >(); r.Fixed <float>(); r.Fixed (); }
364  repeat { r.FixedU<float, 16 >(); r.FixedU<float>(); r.FixedU(); }
365  repeat { r.FixedN<float, 16 >(); r.FixedN<float>(); r.FixedN(); }
366  repeat { r.FixedW<float, 16 >(); r.FixedW<float>(); r.FixedW(); }
367  repeat { r.FixedS<float, 16 >(); r.FixedS<float>(); r.FixedS(); }
368  repeat { r.FixedO<float, 16 >(); r.FixedO<float>(); r.FixedO(); }
369  repeat { r.Float <float, 4, 2>(); r.Float <float>(); r.Float (); }
370  repeat { r.FloatU<float, 4, 2>(); r.FloatU<float>(); r.FloatU(); }
371  repeat { r.FloatN<float, 4, 2>(); r.FloatN<float>(); r.FloatN(); }
372  repeat { r.FloatW<float, 4, 2>(); r.FloatW<float>(); r.FloatW(); }
373  repeat { r.Real<float>(); r.Real(); }
374  }
375  {
376  // Functions returning other random results
377  repeat r.Boolean();
378  repeat r.Prob(0.5f);
379  repeat r.Prob(2.3, 7.0);
380  repeat r.Prob(23, 70);
381  repeat r.Bits< 5>();
382  repeat r.Bits<64>();
383  }
384  {
385  // Normal distribution
386  RandomLib::NormalDistribution<float> nf;
387  RandomLib::NormalDistribution<> nd;
388  repeat nf(r);
389  repeat nd(r, 1.0, 2.0);
390  }
391  {
392  // Exponention distribution
393  RandomLib::ExponentialDistribution<float> ef;
394  RandomLib::ExponentialDistribution<> ed;
395  repeat ef(r);
396  repeat ed(r, 2.0);
397  }
398  {
399  // Discrete probabilities
400  unsigned w[] = { 0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1 };
401  std::vector<int> wi(13);
402  std::vector<float> wf(13);
403  for (int i = 0; i < 13; ++i) {
404  wi[i] = int(w[i]);
405  wf[i] = float(w[i]);
406  }
407  { RandomLib::RandomSelect<unsigned> sel; }
408  { RandomLib::RandomSelect<unsigned> sel(w, w + 13); }
409  { RandomLib::RandomSelect<unsigned> sel(wi.begin(), wi.end()); }
410  { RandomLib::RandomSelect<unsigned> sel(wi); }
411  { RandomLib::RandomSelect<> sel; }
412  { RandomLib::RandomSelect<> sel(w, w + 13); }
413  { RandomLib::RandomSelect<> sel(wi); }
414  { RandomLib::RandomSelect<> sel(wf.begin(), wf.end()); }
415  { RandomLib::RandomSelect<> sel(wf); }
416  {
417  RandomLib::RandomSelect<unsigned> sel;
418  sel.Init(w, w + 13);
419  sel.Init(wi.begin(), wi.end());
420  sel.Init(wi);
421  repeat sel(r);
422  sel.TotalWeight();
423  sel.MaxWeight();
424  sel.Weight(3);
425  sel.Choices();
426  }
427  {
428  RandomLib::RandomSelect<> sel;
429  sel.Init(w, w + 13);
430  sel.Init(wi.begin(), wi.end());
431  sel.Init(wi);
432  sel.Init(wf);
433  repeat sel(r);
434  sel.TotalWeight();
435  sel.MaxWeight();
436  sel.Weight(3);
437  sel.Choices();
438  }
439  // Other distributions
440  { RandomLib::LeadingZeros lz; repeat lz(r); }
441  { RandomLib::ExponentialProb ep; repeat ep(r, 1.5f); }
442  {
443  // Infinite precision random numbers
444  {
445  RandomLib::RandomNumber<1> n;
446  n.Init();
447  n.Digit(r, 10);
448  n.RawDigit(4);
449  n.AddInteger(-2);
450  n.Negate();
451  n.Sign();
452  n.Floor();
453  n.Ceiling();
454  n.Size();
455  n.Range();
456  n.Fraction<float>(r);
457  n.Value<double>(r);
458  RandomLib::RandomNumber<1> p;
459  n.LessThan(r, p);
460  std::ostringstream os;
461  os << n;
462  }
463  {
464  RandomLib::RandomNumber<32> n;
465  n.Init();
466  n.Digit(r, 10);
467  n.RawDigit(4);
468  n.AddInteger(-2);
469  n.Negate();
470  n.Sign();
471  n.Floor();
472  n.Ceiling();
473  n.Size();
474  n.Range();
475  n.Fraction<float>(r);
476  n.Value<double>(r);
477  RandomLib::RandomNumber<32> p;
478  n.LessThan(r, p);
479  std::ostringstream os;
480  os << n;
481  }
482  {
483  if (RandomLib::UniformInteger<char, 4>::Check(37, 7)) {
484  RandomLib::UniformInteger<char, 4> u(r,37);
485  u.Min();
486  u.Max();
487  u.Entropy();
488  u.Add(3);
489  u.LessThan(r, 4, 1);
490  u.LessThanEqual(r, 4, 1);
491  u.GreaterThan(r, 60, 7);
492  u.GreaterThanEqual(r, 60, 7);
493  u.Negate();
494  std::ostringstream os;
495  os << u;
496  os << " " << u(r);
497  }
498  }
499  {
500  RandomLib::UniformInteger<short, 4> u(r,37);
501  u.Min();
502  u.Max();
503  u.Entropy();
504  u.Add(3);
505  u.LessThan(r, 4, 1);
506  u.LessThanEqual(r, 4, 1);
507  u.GreaterThan(r, 60, 7);
508  u.GreaterThanEqual(r, 60, 7);
509  u.Negate();
510  std::ostringstream os;
511  os << u;
512  os << " " << u(r);
513  }
514  {
515  RandomLib::UniformInteger<int, 4> u(r,37);
516  u.Min();
517  u.Max();
518  u.Entropy();
519  u.Add(3);
520  u.LessThan(r, 4, 1);
521  u.LessThanEqual(r, 4, 1);
522  u.GreaterThan(r, 60, 7);
523  u.GreaterThanEqual(r, 60, 7);
524  u.Negate();
525  std::ostringstream os;
526  os << u;
527  os << " " << u(r);
528  }
529  {
530  RandomLib::UniformInteger<long long, 32> u(r,37);
531  u.Min();
532  u.Max();
533  u.Entropy();
534  u.Add(3);
535  u.LessThan(r, 4, 1);
536  u.LessThanEqual(r, 4, 1);
537  u.GreaterThan(r, 60, 7);
538  u.GreaterThanEqual(r, 60, 7);
539  u.Negate();
540  std::ostringstream os;
541  os << u;
542  os << " " << u(r);
543  }
544  // Exact distributions
545  { RandomLib::ExactExponential< 1> ed; repeat ed(r).Value<float >(r); }
546  { RandomLib::ExactExponential<32> ed; repeat ed(r).Value<double>(r); }
547  { RandomLib::ExactNormal< 1> ed; repeat ed(r).Value<float >(r); }
548  { RandomLib::ExactNormal<32> ed; repeat ed(r).Value<double>(r); }
549  { RandomLib::ExactPower< 1> pd; repeat pd(r,2).Value<float >(r); }
550  { RandomLib::ExactPower<32> pd; repeat pd(r,3).Value<double>(r); }
551  { RandomLib::DiscreteNormal<short> pd(7); repeat pd(r); }
552  { RandomLib::DiscreteNormal<int> pd(7,1,1,2); repeat pd(r); }
553  { RandomLib::DiscreteNormal<long> pd(7,1,1,2); repeat pd(r); }
554  { RandomLib::DiscreteNormal<long long> pd(7); repeat pd(r); }
555  { RandomLib::DiscreteNormalAlt<short,1> pd(7); repeat pd(r)(r); }
556  { RandomLib::DiscreteNormalAlt<int,8> pd(7); repeat pd(r)(r); }
557  { RandomLib::DiscreteNormalAlt<long,28> pd(7); repeat pd(r)(r); }
558  { RandomLib::DiscreteNormalAlt<long long,32> pd(7); repeat pd(r)(r); }
559  { RandomLib::InversePiProb pd; repeat pd(r); }
560  { RandomLib::InverseEProb pd; repeat pd(r); }
561  }
562  }
563  {
564  // Setting position in sequence
565  r.Count();
566  r.StepCount(1000);
567  r.Reset();
568  r.SetCount(10000);
569  r.SetStride(10,1);
570  r.SetStride(5);
571  r.GetStride();
572  r.SetStride();
573  }
574  {
575  // Other
576  Random s(r);
577  s = Random::Global;
578  void(s == r);
579  void(s != s);
580  r.swap(s);
581  std::swap(r, s);
582  }
583 }
584 
585 int main(int, char**) {
586  std::cout << "RandomLib Coverage Test\n";
587  coverage32();
588  coverage64();
589  int retval = 0;
590  {
591  using namespace RandomLib;
592  {
593  RandomEngine<MT19937<Random_u32>,MixerMT0<Random_u32> >
594  s("0x123,0x234,0x345,0x456");
595  s.SetCount(999);
596  bool pass = s() == 3460025646U;
597  std::cout << "Check " << s.Name()
598  << (pass ? " passed\n" : " FAILED\n");
599  if (!pass) retval = 1;
600  }
601  {
602  RandomEngine<MT19937<Random_u64>,MixerMT0<Random_u64> >
603  s("0x12345,0,0x23456,0,0x34567,0,0x45678,0");
604  s.SetCount(999);
605  bool pass = s() == 994412663058993407ULL;
606  std::cout << "Check " << s.Name()
607  << (pass ? " passed\n" : " FAILED\n");
608  if (!pass) retval = 1;
609  }
610  {
611  SRandomGenerator32 s("0x1234,0x5678,0x9abc,0xdef0");
612  s.SetCount(999);
613  bool pass = s() == 788493625U;
614  std::cout << "Check " << s.Name()
615  << (pass ? " passed\n" : " FAILED\n");
616  if (!pass) retval = 1;
617  }
618  {
619  SRandomGenerator64 s("5,4,3,2,1");
620  s.SetCount(999);
621  bool pass = s() == 13356980519185762498ULL;
622  std::cout << "Check " << s.Name()
623  << (pass ? " passed\n" : " FAILED\n");
624  if (!pass) retval = 1;
625  }
626  }
627  return retval;
628 }
RandomLib::UniformInteger::LessThan
bool LessThan(Random &r, IntType p, IntType q)
Definition: UniformInteger.hpp:139
coverage32
void coverage32()
Definition: RandomCoverage.cpp:41
UniformInteger.hpp
Header for UniformInteger.
NormalDistribution.hpp
Header for NormalDistribution.
RandomNumber.hpp
Header for RandomNumber.
ExponentialDistribution.hpp
Header for ExponentialDistribution.
RandomSelect.hpp
Header for RandomSelect.
RandomLib::ExponentialProb
The exponential probability.
Definition: ExponentialProb.hpp:61
RandomLib::InverseEProb
Return true with probability 1/e = exp(−1).
Definition: InverseEProb.hpp:30
RandomLib::RandomCanonical
Generate random integers, reals, and booleans.
Definition: RandomCanonical.hpp:55
RandomLib::UniformInteger::GreaterThanEqual
bool GreaterThanEqual(Random &r, IntType p, IntType q)
Definition: UniformInteger.hpp:180
RandomLib::RandomNumber
Infinite precision random numbers.
Definition: RandomNumber.hpp:41
RandomLib::RandomSelect
Random selection from a discrete set.
Definition: RandomSelect.hpp:69
Random.hpp
Header for Random, RandomGenerator.
LeadingZeros.hpp
Header for LeadingZeros.
RandomLib::RandomNumber::Range
std::pair< double, double > Range() const
Definition: RandomNumber.hpp:360
RandomLib::RandomNumber::RawDigit
const unsigned & RawDigit(unsigned k) const
Definition: RandomNumber.hpp:242
repeat
#define repeat
Definition: RandomCoverage.cpp:39
RandomLib::UniformInteger
The partial uniform integer distribution.
Definition: UniformInteger.hpp:80
main
int main(int, char **)
Definition: RandomCoverage.cpp:585
RandomLib::DiscreteNormalAlt
The discrete normal distribution (alternate version).
Definition: DiscreteNormalAlt.hpp:104
DiscreteNormal.hpp
Header for DiscreteNormal.
RandomLib::LeadingZeros
Count of leading zeros.
Definition: LeadingZeros.hpp:34
ExactExponential.hpp
Header for ExactExponential.
RandomLib::MixerMT0
The original MT19937 mixing functionality.
Definition: RandomMixer.hpp:59
RandomLib::UniformInteger::LessThanEqual
bool LessThanEqual(Random &r, IntType p, IntType q)
Definition: UniformInteger.hpp:156
RandomLib::RandomNumber::Value
RealType Value(Random &r)
Definition: RandomNumber.hpp:308
RandomLib::RandomEngine::SetCount
void SetCount(long long n)
Definition: RandomEngine.hpp:458
std::swap
void swap(RandomLib::RandomCanonical< Generator > &r, RandomLib::RandomCanonical< Generator > &s)
Definition: RandomCanonical.hpp:1290
ExponentialProb.hpp
Header for ExponentialProb.
RandomLib::RandomEngine::Name
static std::string Name()
Definition: RandomEngine.hpp:526
RandomLib::RandomNumber::Size
unsigned Size() const
Definition: RandomNumber.hpp:266
RandomLib::RandomNumber::LessThan
bool LessThan(Random &r, RandomNumber &t)
Definition: RandomNumber.hpp:112
coverage64
void coverage64()
Definition: RandomCoverage.cpp:313
RandomLib::Random
RandomCanonical< RandomGenerator > Random
Definition: Random.hpp:135
RandomLib::RandomNumber::Digit
unsigned Digit(Random &r, unsigned k)
Definition: RandomNumber.hpp:224
RandomLib::DiscreteNormal
The discrete normal distribution.
Definition: DiscreteNormal.hpp:140
RandomLib::ExactPower
Sample exactly from a power distribution.
Definition: ExactPower.hpp:35
RandomLib::RandomEngine
Uniform random number generator.
Definition: RandomEngine.hpp:81
InverseEProb.hpp
Header for InverseEProb.
ExactPower.hpp
Header for ExactPower.
RandomLib::ExactExponential
Sample exactly from an exponential distribution.
Definition: ExactExponential.hpp:145
RandomLib::RandomNumber::Fraction
RealType Fraction(Random &r)
Definition: RandomNumber.hpp:279
InversePiProb.hpp
Header for InversePiProb.
RandomLib::ExactNormal
Sample exactly from a normal distribution.
Definition: ExactNormal.hpp:162
DiscreteNormalAlt.hpp
Header for DiscreteNormalAlt.
RandomLib::UniformInteger::GreaterThan
bool GreaterThan(Random &r, IntType p, IntType q)
Definition: UniformInteger.hpp:168
ExactNormal.hpp
Header for ExactNormal.
RandomLib::InversePiProb
Return true with probability 1/π.
Definition: InversePiProb.hpp:104
Generated by   doxygen 1.8.6