1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
/* Random.cpp
Copyright (c) 2014 by Michael Zahniser
Endless Sky is free software: you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later version.
Endless Sky is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "Random.h"
#include <random>
#ifndef __linux__
#include <mutex>
#endif
using namespace std;
// Right now thread_local storage is only supported under Linux.
namespace {
#ifndef __linux__
mutex workaroundMutex;
mt19937_64 gen;
uniform_int_distribution<uint32_t> uniform;
uniform_real_distribution<double> real;
normal_distribution<double> normal;
#else
thread_local mt19937_64 gen;
thread_local uniform_int_distribution<uint32_t> uniform;
thread_local uniform_real_distribution<double> real;
thread_local normal_distribution<double> normal;
#endif
}
// Seed the generator (e.g. to make it produce exactly the same random
// numbers it produced previously).
void Random::Seed(uint64_t seed)
{
#ifndef __linux__
lock_guard<mutex> lock(workaroundMutex);
#endif
gen.seed(seed);
}
uint32_t Random::Int()
{
#ifndef __linux__
lock_guard<mutex> lock(workaroundMutex);
#endif
return uniform(gen);
}
uint32_t Random::Int(uint32_t upper_bound)
{
#ifndef __linux__
lock_guard<mutex> lock(workaroundMutex);
#endif
const uint32_t x = uniform(gen);
return (static_cast<uint64_t>(x) * static_cast<uint64_t>(upper_bound)) >> 32;
}
double Random::Real()
{
#ifndef __linux__
lock_guard<mutex> lock(workaroundMutex);
#endif
return real(gen);
}
// Return the expected number of failures before k successes, when the
// probability of success is p. The mean value will be k / (1 - p).
uint32_t Random::Polya(uint32_t k, double p)
{
negative_binomial_distribution<uint32_t> polya(k, p);
#ifndef __linux__
lock_guard<mutex> lock(workaroundMutex);
#endif
return polya(gen);
}
// Get a number from a binomial distribution (i.e. integer bell curve).
uint32_t Random::Binomial(uint32_t t, double p)
{
binomial_distribution<uint32_t> binomial(t, p);
#ifndef __linux__
lock_guard<mutex> lock(workaroundMutex);
#endif
return binomial(gen);
}
// Get a normally distributed number with standard or specified mean and stddev.
double Random::Normal(double mean, double sigma)
{
#ifndef __linux__
lock_guard<mutex> lock(workaroundMutex);
#endif
return sigma * normal(gen) + mean;
}
|
