nasa/trick | Build 25456501308 | trick_source/sim_services/MonteCarlo/StlRandomGenerator.cpp | Coveralls

1

2

#include <stdexcept>

3

#include "trick/StlRandomGenerator.hh"

4

6

                                       double          in_param_b,

7

                                       unsigned long   in_seed,

8

                                       StlDistribution in_dist_type,

13

15

17

19

20

21

///@details return a pointer-to-base-class for a new StlRandomGeneratorSub object

22

///         of the input-specified type

23

StlRandomGenerator*

25

    double        in_param_a,

26

    double        in_param_b,

27

    unsigned long in_seed,

28

    StlRandomGenerator::StlDistribution in_dist_type,

29

    StlRandomGenerator::StlEngine       in_engine_type)

30

31

32

#if (defined(_HAVE_TR1_RANDOM) || defined(_HAVE_STL_RANDOM))

33

34

#ifdef _HAVE_STL_RANDOM

35

#define UNIFORM_INT_DIST   std::uniform_int_distribution

36

#define UNIFORM_REAL_DIST  std::uniform_real_distribution

37

#define TRICK_DEFAULT_ENGINE_CLASS std::mt19937

38

#else

39

#define UNIFORM_INT_DIST   std::uniform_int

40

#define UNIFORM_REAL_DIST  std::uniform_real

41

#define TRICK_DEFAULT_ENGINE_CLASS std::ranlux_base_01 // because mt19937 doesnt return within canonical range for GCC 4.4.7

42

#endif

43

44

    switch (in_engine_type * 1000 + in_dist_type) {

45

46

    // ------------- TRICK_DEFAULT_ENGINE --------------------------------------

47

48

    case StlRandomGenerator::TRICK_DEFAULT_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

49

        return static_cast< StlRandomGenerator* > (

50

            new StlRandomGeneratorSub< TRICK_DEFAULT_ENGINE_CLASS, std::normal_distribution<double> >

51

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

52

);

53

        break;

54

    case StlRandomGenerator::TRICK_DEFAULT_ENGINE*1000 + StlRandomGenerator::FLAT:

55

        return static_cast< StlRandomGenerator* > (

56

            new StlRandomGeneratorSub< TRICK_DEFAULT_ENGINE_CLASS, UNIFORM_REAL_DIST<double> >

57

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

58

);

59

        break;

60

    case StlRandomGenerator::TRICK_DEFAULT_ENGINE*1000 + StlRandomGenerator::POISSON:

61

        return static_cast< StlRandomGenerator* > (

62

            new StlRandomGeneratorSub< TRICK_DEFAULT_ENGINE_CLASS, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

63

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

64

);

65

        break;

66

67

68

#ifdef _HAVE_TR1_RANDOM

69

    // ------------- RANLUX_BASE_01_ENGINE ---------------------------------------------

70

71

    case StlRandomGenerator::RANLUX_BASE_01_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

72

        return static_cast< StlRandomGenerator* > (

73

            new StlRandomGeneratorSub< std::ranlux_base_01, std::normal_distribution<double> >

74

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

75

);

76

        break;

77

    case StlRandomGenerator::RANLUX_BASE_01_ENGINE*1000 + StlRandomGenerator::FLAT:

78

        return static_cast< StlRandomGenerator* > (

79

            new StlRandomGeneratorSub< std::ranlux_base_01, UNIFORM_REAL_DIST<double> >

80

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

81

);

82

        break;

83

    case StlRandomGenerator::RANLUX_BASE_01_ENGINE*1000 + StlRandomGenerator::POISSON:

84

        return static_cast< StlRandomGenerator* > (

85

            new StlRandomGeneratorSub< std::ranlux_base_01, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

86

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

87

);

88

        break;

89

90

    // ------------- RANLUX_64_BASE_01_ENGINE ---------------------------------------------

91

92

    case StlRandomGenerator::RANLUX_64_BASE_01_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

93

        return static_cast< StlRandomGenerator* > (

94

            new StlRandomGeneratorSub< std::ranlux64_base_01, std::normal_distribution<double> >

95

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

96

);

97

        break;

98

    case StlRandomGenerator::RANLUX_64_BASE_01_ENGINE*1000 + StlRandomGenerator::FLAT:

99

        return static_cast< StlRandomGenerator* > (

100

            new StlRandomGeneratorSub< std::ranlux64_base_01, UNIFORM_REAL_DIST<double> >

101

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

102

);

103

        break;

104

    case StlRandomGenerator::RANLUX_64_BASE_01_ENGINE*1000 + StlRandomGenerator::POISSON:

105

        return static_cast< StlRandomGenerator* > (

106

            new StlRandomGeneratorSub< std::ranlux64_base_01, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

107

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

108

);

109

        break;

110

111

#else

112

113

// std::minstd_rand and mt19937 are not provided for TR1, because GCC 4.4.7 (at least)

114

// they return outside the canonical range 0 <= x < 1.

115

// This causes an infinite loop in std::normal_distribution

116

117

    // ------------- MINSTD_RAND_ENGINE ---------------------------------------------

118

119

    case StlRandomGenerator::MINSTD_RAND_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

120

        return static_cast< StlRandomGenerator* > (

121

            new StlRandomGeneratorSub< std::minstd_rand, std::normal_distribution<double> >

122

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

123

);

124

        break;

125

    case StlRandomGenerator::MINSTD_RAND_ENGINE*1000 + StlRandomGenerator::FLAT:

126

        return static_cast< StlRandomGenerator* > (

127

            new StlRandomGeneratorSub< std::minstd_rand, UNIFORM_REAL_DIST<double> >

128

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

129

);

130

        break;

131

    case StlRandomGenerator::MINSTD_RAND_ENGINE*1000 + StlRandomGenerator::POISSON:

132

        return static_cast< StlRandomGenerator* > (

133

            new StlRandomGeneratorSub< std::minstd_rand, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

134

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

135

);

136

        break;

137

138

    // ------------- MT19937_ENGINE ---------------------------------------------

139

140

    case StlRandomGenerator::MT19937_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

141

        return static_cast< StlRandomGenerator* > (

142

            new StlRandomGeneratorSub< std::mt19937, std::normal_distribution<double> >

143

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

144

);

145

        break;

146

    case StlRandomGenerator::MT19937_ENGINE*1000 + StlRandomGenerator::FLAT:

147

        return static_cast< StlRandomGenerator* > (

148

            new StlRandomGeneratorSub< std::mt19937, UNIFORM_REAL_DIST<double> >

149

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

150

);

151

        break;

152

    case StlRandomGenerator::MT19937_ENGINE*1000 + StlRandomGenerator::POISSON:

153

        return static_cast< StlRandomGenerator* > (

154

            new StlRandomGeneratorSub< std::mt19937, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

155

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

156

);

157

        break;

158

159

// these engines are all C++11 only

160

    // ------------- MT19937_64_ENGINE ---------------------------------------------

161

162

    case StlRandomGenerator::MT19937_64_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

163

        return static_cast< StlRandomGenerator* > (

164

            new StlRandomGeneratorSub< std::mt19937_64, std::normal_distribution<double> >

165

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

166

);

167

        break;

168

    case StlRandomGenerator::MT19937_64_ENGINE*1000 + StlRandomGenerator::FLAT:

169

        return static_cast< StlRandomGenerator* > (

170

            new StlRandomGeneratorSub< std::mt19937_64, UNIFORM_REAL_DIST<double> >

171

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

172

);

173

        break;

174

    case StlRandomGenerator::MT19937_64_ENGINE*1000 + StlRandomGenerator::POISSON:

175

        return static_cast< StlRandomGenerator* > (

176

            new StlRandomGeneratorSub< std::mt19937_64, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

177

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

178

);

179

        break;

180

181

    // ------------- RANLUX_24_BASE_ENGINE ---------------------------------------------

182

183

    case StlRandomGenerator::RANLUX_24_BASE_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

184

        return static_cast< StlRandomGenerator* > (

185

            new StlRandomGeneratorSub< std::ranlux24_base, std::normal_distribution<double> >

186

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

187

);

188

        break;

189

    case StlRandomGenerator::RANLUX_24_BASE_ENGINE*1000 + StlRandomGenerator::FLAT:

190

        return static_cast< StlRandomGenerator* > (

191

            new StlRandomGeneratorSub< std::ranlux24_base, UNIFORM_REAL_DIST<double> >

192

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

193

);

194

        break;

195

    case StlRandomGenerator::RANLUX_24_BASE_ENGINE*1000 + StlRandomGenerator::POISSON:

196

        return static_cast< StlRandomGenerator* > (

197

            new StlRandomGeneratorSub< std::ranlux24_base, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

198

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

199

);

200

        break;

201

202

    // ------------- RANLUX_44_BASE_ENGINE ---------------------------------------------

203

204

    case StlRandomGenerator::RANLUX_44_BASE_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

205

        return static_cast< StlRandomGenerator* > (

206

            new StlRandomGeneratorSub< std::ranlux48_base, std::normal_distribution<double> >

207

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

208

);

209

        break;

210

    case StlRandomGenerator::RANLUX_44_BASE_ENGINE*1000 + StlRandomGenerator::FLAT:

211

        return static_cast< StlRandomGenerator* > (

212

            new StlRandomGeneratorSub< std::ranlux48_base, UNIFORM_REAL_DIST<double> >

213

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

214

);

215

        break;

216

    case StlRandomGenerator::RANLUX_44_BASE_ENGINE*1000 + StlRandomGenerator::POISSON:

217

        return static_cast< StlRandomGenerator* > (

218

            new StlRandomGeneratorSub< std::ranlux48_base, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

219

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

220

);

221

        break;

222

223

    // ------------- RANLUX_24_ENGINE ---------------------------------------------

224

225

    case StlRandomGenerator::RANLUX_24_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

226

        return static_cast< StlRandomGenerator* > (

227

            new StlRandomGeneratorSub< std::ranlux24, std::normal_distribution<double> >

228

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

229

);

230

        break;

231

    case StlRandomGenerator::RANLUX_24_ENGINE*1000 + StlRandomGenerator::FLAT:

232

        return static_cast< StlRandomGenerator* > (

233

            new StlRandomGeneratorSub< std::ranlux24, UNIFORM_REAL_DIST<double> >

234

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

235

);

236

        break;

237

    case StlRandomGenerator::RANLUX_24_ENGINE*1000 + StlRandomGenerator::POISSON:

238

        return static_cast< StlRandomGenerator* > (

239

            new StlRandomGeneratorSub< std::ranlux24, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

240

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

241

);

242

        break;

243

244

    // ------------- RANLUX_44_ENGINE ---------------------------------------------

245

246

    case StlRandomGenerator::RANLUX_44_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

247

        return static_cast< StlRandomGenerator* > (

248

            new StlRandomGeneratorSub< std::ranlux48, std::normal_distribution<double> >

249

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

250

);

251

        break;

252

    case StlRandomGenerator::RANLUX_44_ENGINE*1000 + StlRandomGenerator::FLAT:

253

        return static_cast< StlRandomGenerator* > (

254

            new StlRandomGeneratorSub< std::ranlux48, UNIFORM_REAL_DIST<double> >

255

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

256

);

257

        break;

258

    case StlRandomGenerator::RANLUX_44_ENGINE*1000 + StlRandomGenerator::POISSON:

259

        return static_cast< StlRandomGenerator* > (

260

            new StlRandomGeneratorSub< std::ranlux48, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

261

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

262

);

263

        break;

264

265

    // ------------- KNUTH_B_ENGINE ---------------------------------------------

266

267

    case StlRandomGenerator::KNUTH_B_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:

268

        return static_cast< StlRandomGenerator* > (

269

            new StlRandomGeneratorSub< std::knuth_b, std::normal_distribution<double> >

270

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

271

);

272

        break;

273

    case StlRandomGenerator::KNUTH_B_ENGINE*1000 + StlRandomGenerator::FLAT:

274

        return static_cast< StlRandomGenerator* > (

275

            new StlRandomGeneratorSub< std::knuth_b, UNIFORM_REAL_DIST<double> >

276

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

277

);

278

        break;

279

    case StlRandomGenerator::KNUTH_B_ENGINE*1000 + StlRandomGenerator::POISSON:

280

        return static_cast< StlRandomGenerator* > (

281

            new StlRandomGeneratorSub< std::knuth_b, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >

282

                (in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)

283

);

284

        break;

285

#endif

286

287

    default:

288

        throw std::invalid_argument(std::string("error: StlRandomGeneratorFactory::newGenerator called for unimplemented std::random  (engine,distribution) combination."));

289

290

291

292

#else

293

    // without either _HAVE_TR1_RANDOM or _HAVE_STL_RANDOM, return null pointer.

295

#endif

296

nasa / trick / 25456501308

Source File
Press 'n' to go to next uncovered line, 'b' for previous

1
2	#include <stdexcept>
3	#include "trick/StlRandomGenerator.hh"
4
5	StlRandomGenerator::StlRandomGenerator(double in_param_a,	×
6	double in_param_b,
7	unsigned long in_seed,
8	StlDistribution in_dist_type,
9	StlEngine in_engine_type)	×
10	: initialSeed(in_seed),	×
11	engineEnum(in_engine_type),	×
12	distEnum(in_dist_type)	×
13	{
14	}	×
15
16	StlRandomGenerator::~StlRandomGenerator()	×
17	{
18	}	×
19
20
21	///@details return a pointer-to-base-class for a new StlRandomGeneratorSub object
22	/// of the input-specified type
23	StlRandomGenerator*
24	StlRandomGeneratorFactory::newGenerator(	×
25	double in_param_a,
26	double in_param_b,
27	unsigned long in_seed,
28	StlRandomGenerator::StlDistribution in_dist_type,
29	StlRandomGenerator::StlEngine in_engine_type)
30	{
31
32	#if (defined(_HAVE_TR1_RANDOM) \|\| defined(_HAVE_STL_RANDOM))
33
34	#ifdef _HAVE_STL_RANDOM
35	#define UNIFORM_INT_DIST std::uniform_int_distribution
36	#define UNIFORM_REAL_DIST std::uniform_real_distribution
37	#define TRICK_DEFAULT_ENGINE_CLASS std::mt19937
38	#else
39	#define UNIFORM_INT_DIST std::uniform_int
40	#define UNIFORM_REAL_DIST std::uniform_real
41	#define TRICK_DEFAULT_ENGINE_CLASS std::ranlux_base_01 // because mt19937 doesnt return within canonical range for GCC 4.4.7
42	#endif
43
44	switch (in_engine_type * 1000 + in_dist_type) {
45
46	// ------------- TRICK_DEFAULT_ENGINE --------------------------------------
47
48	case StlRandomGenerator::TRICK_DEFAULT_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
49	return static_cast< StlRandomGenerator* > (
50	new StlRandomGeneratorSub< TRICK_DEFAULT_ENGINE_CLASS, std::normal_distribution<double> >
51	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
52	);
53	break;
54	case StlRandomGenerator::TRICK_DEFAULT_ENGINE*1000 + StlRandomGenerator::FLAT:
55	return static_cast< StlRandomGenerator* > (
56	new StlRandomGeneratorSub< TRICK_DEFAULT_ENGINE_CLASS, UNIFORM_REAL_DIST<double> >
57	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
58	);
59	break;
60	case StlRandomGenerator::TRICK_DEFAULT_ENGINE*1000 + StlRandomGenerator::POISSON:
61	return static_cast< StlRandomGenerator* > (
62	new StlRandomGeneratorSub< TRICK_DEFAULT_ENGINE_CLASS, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
63	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
64	);
65	break;
66
67
68	#ifdef _HAVE_TR1_RANDOM
69	// ------------- RANLUX_BASE_01_ENGINE ---------------------------------------------
70
71	case StlRandomGenerator::RANLUX_BASE_01_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
72	return static_cast< StlRandomGenerator* > (
73	new StlRandomGeneratorSub< std::ranlux_base_01, std::normal_distribution<double> >
74	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
75	);
76	break;
77	case StlRandomGenerator::RANLUX_BASE_01_ENGINE*1000 + StlRandomGenerator::FLAT:
78	return static_cast< StlRandomGenerator* > (
79	new StlRandomGeneratorSub< std::ranlux_base_01, UNIFORM_REAL_DIST<double> >
80	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
81	);
82	break;
83	case StlRandomGenerator::RANLUX_BASE_01_ENGINE*1000 + StlRandomGenerator::POISSON:
84	return static_cast< StlRandomGenerator* > (
85	new StlRandomGeneratorSub< std::ranlux_base_01, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
86	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
87	);
88	break;
89
90	// ------------- RANLUX_64_BASE_01_ENGINE ---------------------------------------------
91
92	case StlRandomGenerator::RANLUX_64_BASE_01_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
93	return static_cast< StlRandomGenerator* > (
94	new StlRandomGeneratorSub< std::ranlux64_base_01, std::normal_distribution<double> >
95	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
96	);
97	break;
98	case StlRandomGenerator::RANLUX_64_BASE_01_ENGINE*1000 + StlRandomGenerator::FLAT:
99	return static_cast< StlRandomGenerator* > (
100	new StlRandomGeneratorSub< std::ranlux64_base_01, UNIFORM_REAL_DIST<double> >
101	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
102	);
103	break;
104	case StlRandomGenerator::RANLUX_64_BASE_01_ENGINE*1000 + StlRandomGenerator::POISSON:
105	return static_cast< StlRandomGenerator* > (
106	new StlRandomGeneratorSub< std::ranlux64_base_01, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
107	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
108	);
109	break;
110
111	#else
112
113	// std::minstd_rand and mt19937 are not provided for TR1, because GCC 4.4.7 (at least)
114	// they return outside the canonical range 0 <= x < 1.
115	// This causes an infinite loop in std::normal_distribution
116
117	// ------------- MINSTD_RAND_ENGINE ---------------------------------------------
118
119	case StlRandomGenerator::MINSTD_RAND_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
120	return static_cast< StlRandomGenerator* > (
121	new StlRandomGeneratorSub< std::minstd_rand, std::normal_distribution<double> >
122	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
123	);
124	break;
125	case StlRandomGenerator::MINSTD_RAND_ENGINE*1000 + StlRandomGenerator::FLAT:
126	return static_cast< StlRandomGenerator* > (
127	new StlRandomGeneratorSub< std::minstd_rand, UNIFORM_REAL_DIST<double> >
128	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
129	);
130	break;
131	case StlRandomGenerator::MINSTD_RAND_ENGINE*1000 + StlRandomGenerator::POISSON:
132	return static_cast< StlRandomGenerator* > (
133	new StlRandomGeneratorSub< std::minstd_rand, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
134	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
135	);
136	break;
137
138	// ------------- MT19937_ENGINE ---------------------------------------------
139
140	case StlRandomGenerator::MT19937_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
141	return static_cast< StlRandomGenerator* > (
142	new StlRandomGeneratorSub< std::mt19937, std::normal_distribution<double> >
143	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
144	);
145	break;
146	case StlRandomGenerator::MT19937_ENGINE*1000 + StlRandomGenerator::FLAT:
147	return static_cast< StlRandomGenerator* > (
148	new StlRandomGeneratorSub< std::mt19937, UNIFORM_REAL_DIST<double> >
149	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
150	);
151	break;
152	case StlRandomGenerator::MT19937_ENGINE*1000 + StlRandomGenerator::POISSON:
153	return static_cast< StlRandomGenerator* > (
154	new StlRandomGeneratorSub< std::mt19937, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
155	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
156	);
157	break;
158
159	// these engines are all C++11 only
160	// ------------- MT19937_64_ENGINE ---------------------------------------------
161
162	case StlRandomGenerator::MT19937_64_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
163	return static_cast< StlRandomGenerator* > (
164	new StlRandomGeneratorSub< std::mt19937_64, std::normal_distribution<double> >
165	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
166	);
167	break;
168	case StlRandomGenerator::MT19937_64_ENGINE*1000 + StlRandomGenerator::FLAT:
169	return static_cast< StlRandomGenerator* > (
170	new StlRandomGeneratorSub< std::mt19937_64, UNIFORM_REAL_DIST<double> >
171	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
172	);
173	break;
174	case StlRandomGenerator::MT19937_64_ENGINE*1000 + StlRandomGenerator::POISSON:
175	return static_cast< StlRandomGenerator* > (
176	new StlRandomGeneratorSub< std::mt19937_64, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
177	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
178	);
179	break;
180
181	// ------------- RANLUX_24_BASE_ENGINE ---------------------------------------------
182
183	case StlRandomGenerator::RANLUX_24_BASE_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
184	return static_cast< StlRandomGenerator* > (
185	new StlRandomGeneratorSub< std::ranlux24_base, std::normal_distribution<double> >
186	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
187	);
188	break;
189	case StlRandomGenerator::RANLUX_24_BASE_ENGINE*1000 + StlRandomGenerator::FLAT:
190	return static_cast< StlRandomGenerator* > (
191	new StlRandomGeneratorSub< std::ranlux24_base, UNIFORM_REAL_DIST<double> >
192	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
193	);
194	break;
195	case StlRandomGenerator::RANLUX_24_BASE_ENGINE*1000 + StlRandomGenerator::POISSON:
196	return static_cast< StlRandomGenerator* > (
197	new StlRandomGeneratorSub< std::ranlux24_base, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
198	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
199	);
200	break;
201
202	// ------------- RANLUX_44_BASE_ENGINE ---------------------------------------------
203
204	case StlRandomGenerator::RANLUX_44_BASE_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
205	return static_cast< StlRandomGenerator* > (
206	new StlRandomGeneratorSub< std::ranlux48_base, std::normal_distribution<double> >
207	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
208	);
209	break;
210	case StlRandomGenerator::RANLUX_44_BASE_ENGINE*1000 + StlRandomGenerator::FLAT:
211	return static_cast< StlRandomGenerator* > (
212	new StlRandomGeneratorSub< std::ranlux48_base, UNIFORM_REAL_DIST<double> >
213	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
214	);
215	break;
216	case StlRandomGenerator::RANLUX_44_BASE_ENGINE*1000 + StlRandomGenerator::POISSON:
217	return static_cast< StlRandomGenerator* > (
218	new StlRandomGeneratorSub< std::ranlux48_base, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
219	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
220	);
221	break;
222
223	// ------------- RANLUX_24_ENGINE ---------------------------------------------
224
225	case StlRandomGenerator::RANLUX_24_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
226	return static_cast< StlRandomGenerator* > (
227	new StlRandomGeneratorSub< std::ranlux24, std::normal_distribution<double> >
228	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
229	);
230	break;
231	case StlRandomGenerator::RANLUX_24_ENGINE*1000 + StlRandomGenerator::FLAT:
232	return static_cast< StlRandomGenerator* > (
233	new StlRandomGeneratorSub< std::ranlux24, UNIFORM_REAL_DIST<double> >
234	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
235	);
236	break;
237	case StlRandomGenerator::RANLUX_24_ENGINE*1000 + StlRandomGenerator::POISSON:
238	return static_cast< StlRandomGenerator* > (
239	new StlRandomGeneratorSub< std::ranlux24, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
240	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
241	);
242	break;
243
244	// ------------- RANLUX_44_ENGINE ---------------------------------------------
245
246	case StlRandomGenerator::RANLUX_44_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
247	return static_cast< StlRandomGenerator* > (
248	new StlRandomGeneratorSub< std::ranlux48, std::normal_distribution<double> >
249	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
250	);
251	break;
252	case StlRandomGenerator::RANLUX_44_ENGINE*1000 + StlRandomGenerator::FLAT:
253	return static_cast< StlRandomGenerator* > (
254	new StlRandomGeneratorSub< std::ranlux48, UNIFORM_REAL_DIST<double> >
255	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
256	);
257	break;
258	case StlRandomGenerator::RANLUX_44_ENGINE*1000 + StlRandomGenerator::POISSON:
259	return static_cast< StlRandomGenerator* > (
260	new StlRandomGeneratorSub< std::ranlux48, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
261	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
262	);
263	break;
264
265	// ------------- KNUTH_B_ENGINE ---------------------------------------------
266
267	case StlRandomGenerator::KNUTH_B_ENGINE*1000 + StlRandomGenerator::GAUSSIAN:
268	return static_cast< StlRandomGenerator* > (
269	new StlRandomGeneratorSub< std::knuth_b, std::normal_distribution<double> >
270	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
271	);
272	break;
273	case StlRandomGenerator::KNUTH_B_ENGINE*1000 + StlRandomGenerator::FLAT:
274	return static_cast< StlRandomGenerator* > (
275	new StlRandomGeneratorSub< std::knuth_b, UNIFORM_REAL_DIST<double> >
276	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
277	);
278	break;
279	case StlRandomGenerator::KNUTH_B_ENGINE*1000 + StlRandomGenerator::POISSON:
280	return static_cast< StlRandomGenerator* > (
281	new StlRandomGeneratorSub< std::knuth_b, std::poisson_distribution<STL_POISSON_TEMPLATE_TYPES> >
282	(in_param_a, in_param_b, in_seed, in_dist_type, in_engine_type)
283	);
284	break;
285	#endif
286
287	default:
288	throw std::invalid_argument(std::string("error: StlRandomGeneratorFactory::newGenerator called for unimplemented std::random (engine,distribution) combination."));
289	}
290
291
292	#else
293	// without either _HAVE_TR1_RANDOM or _HAVE_STL_RANDOM, return null pointer.
294	return 0; // ???? what was I thinking here static_cast< StlRandomGenerator* >( 0 );	×
295	#endif
296	}

nasa / trick / 25456501308

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous