Fork me on GitHub

source: svn/trunk/external/fastjet/internal/BasicRandom.hh@ 1204

Last change on this file since 1204 was 859, checked in by Pavel Demin, 12 years ago

update fastjet to version 3.0.3

File size: 5.5 KB
Line 
1// Simple random number generator class taken from nlojet++.
2// Some doxygen-style comments added by Gavin Salam, August 2006.
3// $Id: BasicRandom.hh 1761 2010-09-16 10:43:18Z soyez $
4//
5// Copyright (C) 2002 Zoltan Nagy
6//
7// This program is free software; you can redistribute it and/or modify
8// it under the terms of the GNU General Public License as published by
9// the Free Software Foundation; either version 2 of the License, or
10// (at your option) any later version.
11//
12// This program is distributed in the hope that it will be useful,
13// but WITHOUT ANY WARRANTY; without even the implied warranty of
14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15// GNU General Public License for more details.
16//
17// You should have received a copy of the GNU General Public License
18// along with this program; if not, write to the Free Software
19// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20#ifndef __FASTJET_BASICRANDOM_HH__
21#define __FASTJET_BASICRANDOM_HH__ 1
22
23// Standard includes
24#include <iostream>
25#include <vector>
26#include <cassert>
27#include "fastjet/internal/base.hh"
28
29FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh
30
31/// \if internal_doc
32/// @ingroup internal
33/// \class BasicRandom
34/// Base class for random number generator of a generic value type
35/// \endif
36template<typename _Tp> class BasicRandom {
37public:
38 typedef _Tp value_type;
39 typedef unsigned int size_type;
40 typedef value_type* pointer;
41
42 // give pseudo random numbers
43 value_type operator() ();
44 void operator() (size_type, pointer);
45
46 // (re)initialize the random number generator
47 void randomize(void *);
48
49 // minimum and maximum values
50 static value_type min();
51 static value_type max();
52
53 // print the informations about the generator to the stream
54 void print_info(std::ostream& __os = std::cout);
55};
56
57// default random generator
58int __default_random_generator(int *__iseed);
59
60
61// specializations
62
63/// \if internal_doc
64/// @ingroup internal
65/// template specialization (int) for the BasicRandom template class.
66/// \endif
67template<>
68class BasicRandom<int>
69{
70public:
71 typedef int value_type;
72 typedef unsigned int size_type;
73 typedef value_type* pointer;
74
75 // constructors
76 explicit BasicRandom(int __s1 = 12345, int __s2 = 67890) {
77 _M_iseed[0] = __s1;
78 _M_iseed[1] = __s2;
79 }
80
81 // give pseudo random numbers
82 value_type operator() () {
83 return __default_random_generator(_M_iseed);
84 }
85
86 void operator() (size_type __n, pointer __res) {
87 for(size_type __i = 0; __i < __n; __i++)
88 __res[__i] = __default_random_generator(_M_iseed);
89 }
90
91 // (re)initialize the random number generator
92 void randomize(void *__iseed) {
93 int *__new_seed = (int*) __iseed;
94 _M_iseed[0] = __new_seed[0];
95 _M_iseed[1] = __new_seed[1];
96 }
97
98 void set_status(const std::vector<int> & __iseed) {
99 assert(__iseed.size() >= 2);
100 _M_iseed[0] = __iseed[0];
101 _M_iseed[1] = __iseed[1];
102 }
103
104 void get_status(std::vector<int> & __iseed) {
105 __iseed.resize(2);
106 __iseed[0] = _M_iseed[0];
107 __iseed[1] = _M_iseed[1];
108 }
109
110 // minimum and maximum values
111 inline static value_type min() { return 0;}
112 inline static value_type max() { return 2147483647;}
113
114 // print the informations about the generator to the stream
115 void print_info(std::ostream& __os = std::cout) {
116 __os<<"BasicRandom<int> : "<<_M_iseed[0]<<", "<<_M_iseed[1]<<std::endl;
117 }
118
119private:
120 int _M_iseed[2];
121};
122
123
124/// \if internal_doc
125/// @ingroup internal
126/// template specialization (double) for the BasicRandom template class.
127/// \endif
128template<> class BasicRandom<double> {
129public:
130 typedef double value_type;
131 typedef unsigned int size_type;
132 typedef value_type* pointer;
133
134 /// constructor that takes two integers to specify the seed
135 explicit BasicRandom(int __s1 = 12345, int __s2 = 67890) {
136 _M_iseed[0] = __s1;
137 _M_iseed[1] = __s2;
138 }
139
140 /// return a single pseudorandom double number, in the range 0.0 to 1.0
141 /// (not sure whether this range is open or closed)
142 value_type operator() () {
143 return 4.6566128752457969241e-10*__default_random_generator(_M_iseed);
144 }
145
146 /// given a pointer __res to the beginning of an array, fill that array
147 /// with __n random numbers
148 void operator() (size_type __n, pointer __res) {
149 for(size_type __i = 0; __i < __n; __i++)
150 __res[__i] = this -> operator()();
151 }
152
153 /// (re)initialize the random number generator from an array of seeds
154 void randomize(void *__iseed) {
155 int *__new_seed = (int*) __iseed;
156 _M_iseed[0] = __new_seed[0];
157 _M_iseed[1] = __new_seed[1];
158 }
159
160 void set_status(const std::vector<int> & __iseed) {
161 assert(__iseed.size() >= 2);
162 _M_iseed[0] = __iseed[0];
163 _M_iseed[1] = __iseed[1];
164 }
165
166 void get_status(std::vector<int> & __iseed) {
167 __iseed.resize(2);
168 __iseed[0] = _M_iseed[0];
169 __iseed[1] = _M_iseed[1];
170 }
171
172 /// minimum value returned by the generator
173 inline static value_type min() { return 0.0;}
174 /// maximum value returned by the generator
175 inline static value_type max() { return 1.0;}
176
177 /// print information about the generator to the stream
178 void print_info(std::ostream& __os = std::cout) {
179 __os<<"BasicRandom<double> : "<<_M_iseed[0]<<", "<<_M_iseed[1]<<std::endl;
180 }
181
182private:
183 int _M_iseed[2];
184};
185
186// globally defined random number generator
187extern BasicRandom<int> _G_random_int;
188extern BasicRandom<double> _G_random_double;
189
190
191FASTJET_END_NAMESPACE
192
193#endif // __FASTJET_BASICRANDOM_HH__
194
Note: See TracBrowser for help on using the repository browser.