src/OpenFOAM/primitives/random/cachedRandom/cachedRandom.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 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::cachedRandom
  26
  27 Description
  28     Random number generator.
  29
  30     Pre-computes and caches samples on construction, so that when sample01()
  31     is called, the function simply returns the next (pre-computed) sample. On
  32     reaching the last sample, the sample sequence is repeated.
  33
  34     Constructed using a seed and sample count. If the supplied count is
  35     negative, no caching is performed, and a new sample is generated on each
  36     call to sample01().
  37
  38     Note: the copy constructor cannot be used if count = -1.
  39
  40 SourceFiles
  41     cachedRandomI.H
  42     cachedRandom.C
  43     cachedRandomTemplates.C
  44
  45 \*---------------------------------------------------------------------------*/
  46
  47 #ifndef cachedRandom_H
  48 #define cachedRandom_H
  49
  50 #include "scalarList.H"
  51
  52 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  53
  54 namespace Foam
  55 {
  56
  57 // Forward declaration of classes
  58 class cachedRandom;
  59
  60 /*---------------------------------------------------------------------------*\
  61                        Class cachedRandom Declaration
  62 \*---------------------------------------------------------------------------*/
  63
  64 class cachedRandom
  65 {
  66 private:
  67
  68     // Private data
  69
  70         //- Initial random number seed
  71         label seed_;
  72
  73         //- List of scalar samples
  74         scalarList samples_;
  75
  76         //- Current sample marker
  77         label sampleI_;
  78
  79
  80     // Private Member Functions
  81
  82         //- Returns the current sample
  83         scalar scalar01();
  84
  85
  86 public:
  87
  88
  89     // Constructors
  90
  91         //- Construct given seed and sample count
  92         cachedRandom(const label seed, const label count);
  93
  94         //- Copy constructor with optional reset of sampleI
  95         cachedRandom(const cachedRandom& cr, const bool reset = false);
  96
  97
  98     // Destructor
  99     ~cachedRandom();
 100
 101
 102     // Member functions
 103
 104         // Access
 105
 106             //- Return const access to the initial random number seed
 107             inline label seed() const;
 108
 109             //- Return const access to the list of samples
 110             inline const scalarList& samples() const;
 111
 112             //- Return the current sample marker
 113             inline label sampleI() const;
 114
 115
 116         // Manipulation
 117
 118             //- Return non-const access to the sample marker
 119             inline label& sampleI();
 120
 121
 122         // Evaluation
 123
 124             //- Return a sample whose components lie in the range 0-1
 125             template<class Type>
 126             Type sample01();
 127
 128             //- Return a sample between start and end
 129             template<class Type>
 130             Type position(const Type& start, const Type& end);
 131
 132             //- Randomise value in the range 0-1
 133             template<class Type>
 134             void randomise01(Type& value);
 135
 136
 137         // Operators
 138
 139             //- Assignment operator
 140             void operator=(const cachedRandom& cr);
 141 };
 142
 143
 144 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 145 // Template specialisations
 146
 147 template<>
 148 label cachedRandom::sample01<label>();
 149
 150 template<>
 151 scalar cachedRandom::sample01<scalar>();
 152
 153 template<>
 154 label cachedRandom::position<label>(const label& start, const label& end);
 155
 156 template<>
 157 scalar cachedRandom::position<scalar>
 158 (
 159     const scalar& start,
 160     const scalar& end
 161 );
 162
 163 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 164
 165 } // End namespace Foam
 166
 167 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 168
 169 #include "cachedRandomI.H"
 170
 171 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 172
 173 #ifdef NoRepository
 174 #   include "cachedRandomTemplates.C"
 175 #endif
 176
 177 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 178
 179 #endif
 180
 181 // ************************************************************************* //