Random.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2018-2022 OpenFOAM Foundation
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9  This file is part of OpenFOAM.
10 
11  OpenFOAM is free software: you can redistribute it and/or modify it
12  under the terms of the GNU General Public License as published by
13  the Free Software Foundation, either version 3 of the License, or
14  (at your option) any later version.
15 
16  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19  for more details.
20 
21  You should have received a copy of the GNU General Public License
22  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
23 
24 Class
25  Foam::Random
26 
27 Description
28  Random number generator
29 
30  This is a clone of the drand48 algorithm. This is significantly quicker
31  than drand48, presumably due to the compiler inlining the sampling methods.
32  It is also significantly quicker than the standard library linear
33  congruential engine, as it does not use Schrage's algorithm to prevent
34  overflow.
35 
36  See <http://pubs.opengroup.org/onlinepubs/007908775/xsh/drand48.html> for
37  details of the seeding and iteration sequence.
38 
39 SourceFiles
40  RandomI.H
41 
42 \*---------------------------------------------------------------------------*/
43 
44 #ifndef Random_H
45 #define Random_H
46 
47 #include "scalar.H"
48 
49 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
50 
51 namespace Foam
52 {
53 
54 /*---------------------------------------------------------------------------*\
55  Class Random Declaration
56 \*---------------------------------------------------------------------------*/
57 
58 class Random
59 {
60  // Private Typedefs
61 
62  //- Working type
63  typedef uint64_t type;
64 
65 
66  // Private static data
67 
68  //- The parameters of the linear congruential iteration
69  static const type A = 0x5DEECE66D, C = 0xB, M = type(1) << 48;
70 
71 
72  // Private Data
73 
74  //- The stored integer
75  type x_;
76 
77  //- Is a normal scalar sample stored?
78  bool scalarNormalStored_;
79 
80  //- A stored normal scalar sample
81  scalar scalarNormalValue_;
82 
83 
84  // Private Member Functions
85 
86  //- Advance the state and return an integer sample
87  inline type sample();
88 
89 
90 public:
91 
92  // Constructors
93 
94  //- Construct from a seed
95  inline Random(const label s);
96 
97 
98  //- Destructor
99  inline ~Random();
100 
101 
102  // Member Functions
103 
104  // Scalars
105 
106  //- Advance the state and return a scalar sample from a uniform
107  // distribution between zero and one
108  inline scalar scalar01();
109 
110  //- Advance the state and return a scalar sample from a uniform
111  // distribution between two limits
112  inline scalar scalarAB(const scalar a, const scalar b);
113 
114  //- Advance the state and return a scalar sample from a normal
115  // distribution with mean zero and standard deviation one
116  scalar scalarNormal();
117 
118 
119  // Other types
120 
121  //- Advance the state and return a sample of a given type from a
122  // uniform distribution between zero and one
123  template<class Type>
124  inline Type sample01();
125 
126  //- Advance the state and return a sample of a given type from a
127  // uniform distribution between two limits
128  template<class Type>
129  inline Type sampleAB(const Type& a, const Type& b);
130 
131  //- Advance the state and return a sample of a given type from a
132  // normal distribution with mean zero and standard deviation one
133  template<class Type>
134  inline Type sampleNormal();
135 
136 
137  // Global scalars
138 
139  //- Advance the state and return a scalar sample from a uniform
140  // distribution between zero and one. Synchronises across all
141  // cores. Use of this is discouraged. It is expensive and
142  // introduces non-randomness in all cores other then the master.
143  scalar globalScalar01();
144 
145 
146  //- Randomly permute a list
147  template<class Container>
148  inline void permute(Container& l);
149 };
150 
151 
152 template<>
153 inline scalar Random::sample01();
154 
155 template<>
156 inline label Random::sample01();
157 
158 template<>
159 inline scalar Random::sampleAB(const scalar& a, const scalar& b);
160 
161 template<>
162 inline label Random::sampleAB(const label& a, const label& b);
163 
164 template<>
165 inline scalar Random::sampleNormal();
166 
167 
168 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
169 
170 } // End namespace Foam
171 
172 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
173 
174 #include "RandomI.H"
175 
176 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
177 
178 #endif
179 
180 // ************************************************************************* //
Graphite solid properties.
Definition: C.H:51
Random number generator.
Definition: Random.H:58
scalar scalarAB(const scalar a, const scalar b)
Advance the state and return a scalar sample from a uniform.
Definition: RandomI.H:62
scalar scalar01()
Advance the state and return a scalar sample from a uniform.
Definition: RandomI.H:56
scalar globalScalar01()
Advance the state and return a scalar sample from a uniform.
Definition: Random.C:94
Type sample01()
Advance the state and return a sample of a given type from a.
Definition: RandomI.H:69
~Random()
Destructor.
Definition: RandomI.H:50
scalar scalarNormal()
Advance the state and return a scalar sample from a normal.
Definition: Random.C:31
void permute(Container &l)
Randomly permute a list.
Definition: RandomI.H:139
Type sampleAB(const Type &a, const Type &b)
Advance the state and return a sample of a given type from a.
Definition: RandomI.H:97
Type sampleNormal()
Advance the state and return a sample of a given type from a.
Definition: RandomI.H:118
Random(const label s)
Construct from a seed.
Definition: RandomI.H:40
gmvFile<< "tracers "<< particles.size()<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){ gmvFile<< iter().position().x()<< " ";}gmvFile<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){ gmvFile<< iter().position().y()<< " ";}gmvFile<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){ gmvFile<< iter().position().z()<< " ";}gmvFile<< nl;forAll(lagrangianScalarNames, i){ word name=lagrangianScalarNames[i];IOField< scalar > s(IOobject(name, runTime.name(), cloud::prefix, mesh, IOobject::MUST_READ, IOobject::NO_WRITE))
volScalarField & b
Definition: createFields.H:27
Namespace for OpenFOAM.
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59