00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #ifndef RNG_XDIV_H
00012 #define RNG_XDIV_H
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 #include "Utility/SequenceGen.h"
00031
00032
00033 class RNGXDiv {
00034
00035 public:
00036
00037 typedef double Return_t;
00038
00039 public:
00040
00041 RNGXDiv(int advance = 0) {
00042
00043
00044 SeedUpper = long(FirstSeed * INV_SQR_RANMAX);
00045 SeedLower = FirstSeed - SeedUpper * SQR_RANMAX;
00046 AdvanceSeed(advance);
00047 }
00048
00049
00050 RNGXDiv(const RNGXDiv& rng)
00051 : SeedLower(rng.SeedLower), SeedUpper(rng.SeedUpper),
00052 RandLower(rng.RandLower), RandUpper(rng.RandUpper) {}
00053
00054
00055 ~RNGXDiv(void) {}
00056
00057
00058 inline void AdvanceSeed(int advance = 0) {
00059 for (int iadv=0; iadv<advance; iadv++)
00060 advijk();
00061
00062 RandLower = SeedLower;
00063 RandUpper = SeedUpper;
00064 }
00065
00066
00067 inline void SetSeed(unsigned long seed) {
00068 Return_t rijk = Return_t(seed) + FirstSeed;
00069 SeedUpper = long(rijk * INV_SQR_RANMAX);
00070 SeedLower = rijk - SeedUpper * SQR_RANMAX;
00071
00072 RandLower = SeedLower;
00073 RandUpper = SeedUpper;
00074 }
00075
00076
00077 inline unsigned long GetSeed(void) const {
00078
00079 Return_t rijk = SeedLower + SeedUpper * SQR_RANMAX;
00080 unsigned long seed = (unsigned long) (rijk - FirstSeed);
00081 return seed;
00082 }
00083
00084
00085 inline Return_t GetRandom(void) const {
00086 Return_t a = RandMultLower * RandLower;
00087 Return_t b = RandMultUpper * RandLower +
00088 RandMultLower * RandUpper + long(a * INV_SQR_RANMAX);
00089 RandLower = a - long(a * INV_SQR_RANMAX) * SQR_RANMAX;
00090 RandUpper = b - long(b * INV_SQR_RANMAX) * SQR_RANMAX;
00091 return ( (RandUpper * SQR_RANMAX + RandLower) * INV_RANMAX );
00092 }
00093
00094
00095 inline Return_t operator()(void) const { return GetRandom(); }
00096
00097
00098 inline operator Return_t() const { return GetRandom(); }
00099
00100
00101 static Return_t GetRandMax(void) { return Return_t(RANDOM_MAX); }
00102
00103 private:
00104 double SeedLower, SeedUpper;
00105 mutable double RandLower, RandUpper;
00106
00107
00108 inline void advijk(void) {
00109 Return_t a = SeedMultLower * SeedLower;
00110 Return_t b = (SeedMultUpper * SeedLower -
00111 long(SeedMultUpper * SeedLower * INV_SQR_RANMAX) * SQR_RANMAX) +
00112 (SeedMultLower * SeedUpper -
00113 long(SeedMultLower * SeedUpper * INV_SQR_RANMAX) * SQR_RANMAX) +
00114 long(a * INV_SQR_RANMAX);
00115 SeedLower = a - long(a * INV_SQR_RANMAX) * SQR_RANMAX;
00116 SeedUpper = b - long(b * INV_SQR_RANMAX) * SQR_RANMAX;
00117 }
00118
00119 static const double RANDOM_MAX;
00120 static const double SQR_RANMAX;
00121 static const double INV_SQR_RANMAX;
00122 static const double INV_RANMAX;
00123 static const double SeedMultUpper;
00124 static const double SeedMultLower;
00125 static const double RandMultUpper;
00126 static const double RandMultLower;
00127 static const double FirstSeed;
00128 };
00129
00130 RNG_BASIC_MATH(RNGXDiv)
00131
00132
00133
00134
00135
00136
00137
00138 class RNGXDivSequence : public SequenceGen<RNGXDiv> {
00139
00140 public:
00141
00142 RNGXDivSequence(int advance = 0)
00143 : SequenceGen<RNGXDiv>(RNGXDiv(advance)) {}
00144
00145
00146 RNGXDivSequence(const RNGXDivSequence& rngseq)
00147 : SequenceGen<RNGXDiv>(rngseq.getGenerator()) {}
00148
00149
00150 ~RNGXDivSequence(void) {}
00151
00152
00153 inline void AdvanceSeed(int adv = 0) { getGenerator().AdvanceSeed(adv); }
00154 inline void SetSeed(unsigned long seed) { getGenerator().SetSeed(seed); }
00155 inline unsigned long GetSeed(void) const { return getGenerator().GetSeed(); }
00156 inline Return_t GetRandom(void) { return getGenerator().GetRandom(); }
00157 inline Return_t operator()(void) { return getGenerator().GetRandom(); }
00158 static Return_t GetRandMax(void) { return RNGXDiv::GetRandMax(); }
00159 };
00160
00161
00162 #endif // RNG_XDIV_H
00163
00164
00165
00166
00167
00168
00169