Logo ROOT   6.19/01
Reference Guide
QuasiRandom.h
Go to the documentation of this file.
1 // @(#)root/mathmore:$Id$
2 // Author: L. Moneta, A. Zsenei 08/2005
3 
4  /**********************************************************************
5  * *
6  * Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
7  * *
8  * This library is free software; you can redistribute it and/or *
9  * modify it under the terms of the GNU General Public License *
10  * as published by the Free Software Foundation; either version 2 *
11  * of the License, or (at your option) any later version. *
12  * *
13  * This library is distributed in the hope that it will be useful, *
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
16  * General Public License for more details. *
17  * *
18  * You should have received a copy of the GNU General Public License *
19  * along with this library (see file COPYING); if not, write *
20  * to the Free Software Foundation, Inc., 59 Temple Place, Suite *
21  * 330, Boston, MA 02111-1307 USA, or contact the author. *
22  * *
23  **********************************************************************/
24 
25 // Header file for class GSLRandom
26 //
27 // Created by: moneta at Sun Nov 21 16:26:03 2004
28 //
29 // Last update: Sun Nov 21 16:26:03 2004
30 //
31 #ifndef ROOT_Math_QuasiRandom
32 #define ROOT_Math_QuasiRandom
33 
34 #include <string>
35 
36 /**
37  @defgroup QuasiRandom QuasiRandom number generators and distributions
38  Classes for generating QuasiRandom numbers and based on GSL
39  @ingroup Random
40  @ingroup MathMore
41 */
42 
43 
44 
45 namespace ROOT {
46 namespace Math {
47 
48 
49 //_____________________________________________________________________________________
50 /**
51  User class for MathMore random numbers template on the Engine type.
52  The API of this class followed that of the class ROOT::Math::Random
53  It must be implemented using as Engine one of the derived classes of
54  ROOT::Math::GSLQuasiRandomEngine, like ROOT::Math::GSLQrngSobol
55 
56  @ingroup QuasiRandom
57 
58 */
59 template < class Engine>
60 class QuasiRandom {
61 
62 public:
63 
64 
65  /**
66  Create a QuasiRandom generator. Use default engine constructor.
67  Engine will be initialized via Initialize() function in order to
68  allocate resources
69  */
70  QuasiRandom(unsigned int dimension = 1) {
71  fEngine.Initialize(dimension);
72  }
73 
74 
75  /**
76  Create a QuasiRandom generator based on a provided generic engine.
77  Engine will be initialized via Initialize() function in order to
78  allocate resources
79  */
80  explicit QuasiRandom(const Engine & e, unsigned int dimension = 1) : fEngine(e) {
81  fEngine.Initialize(dimension);
82  }
83 
84  /**
85  Destructor: call Terminate() function of engine to free any
86  allocated resource
87  */
89  fEngine.Terminate();
90  }
91 
92  /**
93  Generate next quasi random numbers points
94  */
95  bool Next(double * x) {
96  return fEngine(x);
97  }
98 
99  /**
100  Generate next quasi random numbers point (1 - dimension)
101  */
102  double Next() {
103  return fEngine();
104  }
105 
106  /**
107  Generate quasi random numbers between ]0,1[
108  0 and 1 are excluded
109  Function to be compatible with ROOT TRandom compatibility
110  */
111  double Rndm() {
112  return fEngine();
113  }
114 
115  /**
116  skip the next n number and jumb directly to the current state + n
117  */
118  bool Skip(unsigned int n) {
119  return fEngine.Skip(n);
120  }
121  /**
122  Generate an array of random numbers between ]0,1[
123  Function to preserve ROOT Trandom compatibility
124  The array will be filled as x1,y1,z1,....x2,y2,z2,...
125  */
126  bool RndmArray(int n, double * array) {
127  return fEngine.GenerateArray(array, array+n*NDim());
128  }
129 
130  /**
131  Return the type (name) of the used generator
132  */
133  std::string Type() const {
134  return fEngine.Name();
135  }
136 
137  /**
138  Return the size of the generator state
139  */
140  unsigned int EngineSize() const {
141  return fEngine.Size();
142  }
143 
144  /**
145  Return the dimension of the generator
146  */
147  unsigned int NDim() const {
148  return fEngine.NDim();
149  }
150 
151  /**
152  Return the name of the generator
153  */
154  std::string Name() const {
155  return fEngine.Name();
156  }
157 
158 private:
159 
160  Engine fEngine;
161 
162 };
163 
164 
165 
166 } // namespace Math
167 } // namespace ROOT
168 
169 #include "Math/GSLQuasiRandom.h"
170 
171 
172 
173 
174 namespace ROOT {
175 namespace Math {
176 
177 
180 
181 } // namespace Math
182 } // namespace ROOT
183 
184 
185 #endif /* ROOT_Math_QuasiRandom */
186 
187 
188 
VSD Structures.
Definition: StringConv.hxx:21
QuasiRandom(unsigned int dimension=1)
Create a QuasiRandom generator.
Definition: QuasiRandom.h:70
User class for MathMore random numbers template on the Engine type.
Definition: QuasiRandom.h:60
bool RndmArray(int n, double *array)
Generate an array of random numbers between ]0,1[ Function to preserve ROOT Trandom compatibility The...
Definition: QuasiRandom.h:126
double Next()
Generate next quasi random numbers point (1 - dimension)
Definition: QuasiRandom.h:102
QuasiRandom(const Engine &e, unsigned int dimension=1)
Create a QuasiRandom generator based on a provided generic engine.
Definition: QuasiRandom.h:80
QuasiRandom< ROOT::Math::GSLQRngSobol > QuasiRandomSobol
Definition: QuasiRandom.h:178
double Rndm()
Generate quasi random numbers between ]0,1[ 0 and 1 are excluded Function to be compatible with ROOT ...
Definition: QuasiRandom.h:111
QuasiRandom< ROOT::Math::GSLQRngNiederreiter2 > QuasiRandomNiederreiter
Definition: QuasiRandom.h:179
Double_t x[n]
Definition: legend1.C:17
std::string Name() const
Return the name of the generator.
Definition: QuasiRandom.h:154
bool Next(double *x)
Generate next quasi random numbers points.
Definition: QuasiRandom.h:95
bool Skip(unsigned int n)
skip the next n number and jumb directly to the current state + n
Definition: QuasiRandom.h:118
you should not use this method at all Int_t Int_t Double_t Double_t Double_t e
Definition: TRolke.cxx:630
Namespace for new Math classes and functions.
~QuasiRandom()
Destructor: call Terminate() function of engine to free any allocated resource.
Definition: QuasiRandom.h:88
std::string Type() const
Return the type (name) of the used generator.
Definition: QuasiRandom.h:133
unsigned int EngineSize() const
Return the size of the generator state.
Definition: QuasiRandom.h:140
unsigned int NDim() const
Return the dimension of the generator.
Definition: QuasiRandom.h:147
const Int_t n
Definition: legend1.C:16