00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef __FASTJET_BASICRANDOM_HH__
00021 #define __FASTJET_BASICRANDOM_HH__ 1
00022
00023
00024 #include <iostream>
00025 #include <vector>
00026 #include <cassert>
00027 #include "fastjet/internal/base.hh"
00028
00029 FASTJET_BEGIN_NAMESPACE
00030
00031 template<typename _Tp> class BasicRandom {
00032 public:
00033 typedef _Tp value_type;
00034 typedef unsigned int size_type;
00035 typedef value_type* pointer;
00036
00037
00038 value_type operator() ();
00039 void operator() (size_type, pointer);
00040
00041
00042 void randomize(void *);
00043
00044
00045 static value_type min();
00046 static value_type max();
00047
00048
00049 void print_info(std::ostream& __os = std::cout);
00050 };
00051
00052
00053 int __default_random_generator(int *__iseed);
00054
00055
00056
00057 template<>
00058 class BasicRandom<int>
00059 {
00060 public:
00061 typedef int value_type;
00062 typedef unsigned int size_type;
00063 typedef value_type* pointer;
00064
00065
00066 explicit BasicRandom(int __s1 = 12345, int __s2 = 67890) {
00067 _M_iseed[0] = __s1;
00068 _M_iseed[1] = __s2;
00069 }
00070
00071
00072 value_type operator() () {
00073 return __default_random_generator(_M_iseed);
00074 }
00075
00076 void operator() (size_type __n, pointer __res) {
00077 for(size_type __i = 0; __i < __n; __i++)
00078 __res[__i] = __default_random_generator(_M_iseed);
00079 }
00080
00081
00082 void randomize(void *__iseed) {
00083 int *__new_seed = (int*) __iseed;
00084 _M_iseed[0] = __new_seed[0];
00085 _M_iseed[1] = __new_seed[1];
00086 }
00087
00088 void set_status(const std::vector<int> & __iseed) {
00089 assert(__iseed.size() >= 2);
00090 _M_iseed[0] = __iseed[0];
00091 _M_iseed[1] = __iseed[1];
00092 }
00093
00094 void get_status(std::vector<int> & __iseed) {
00095 __iseed.resize(2);
00096 __iseed[0] = _M_iseed[0];
00097 __iseed[1] = _M_iseed[1];
00098 }
00099
00100
00101 inline static value_type min() { return 0;}
00102 inline static value_type max() { return 2147483647;}
00103
00104
00105 void print_info(std::ostream& __os = std::cout) {
00106 __os<<"BasicRandom<int> : "<<_M_iseed[0]<<", "<<_M_iseed[1]<<std::endl;
00107 }
00108
00109 private:
00110 int _M_iseed[2];
00111 };
00112
00113
00115 template<> class BasicRandom<double> {
00116 public:
00117 typedef double value_type;
00118 typedef unsigned int size_type;
00119 typedef value_type* pointer;
00120
00122 explicit BasicRandom(int __s1 = 12345, int __s2 = 67890) {
00123 _M_iseed[0] = __s1;
00124 _M_iseed[1] = __s2;
00125 }
00126
00129 value_type operator() () {
00130 return 4.6566128752457969241e-10*__default_random_generator(_M_iseed);
00131 }
00132
00135 void operator() (size_type __n, pointer __res) {
00136 for(size_type __i = 0; __i < __n; __i++)
00137 __res[__i] = this -> operator()();
00138 }
00139
00141 void randomize(void *__iseed) {
00142 int *__new_seed = (int*) __iseed;
00143 _M_iseed[0] = __new_seed[0];
00144 _M_iseed[1] = __new_seed[1];
00145 }
00146
00147 void set_status(const std::vector<int> & __iseed) {
00148 assert(__iseed.size() >= 2);
00149 _M_iseed[0] = __iseed[0];
00150 _M_iseed[1] = __iseed[1];
00151 }
00152
00153 void get_status(std::vector<int> & __iseed) {
00154 __iseed.resize(2);
00155 __iseed[0] = _M_iseed[0];
00156 __iseed[1] = _M_iseed[1];
00157 }
00158
00160 inline static value_type min() { return 0.0;}
00162 inline static value_type max() { return 1.0;}
00163
00165 void print_info(std::ostream& __os = std::cout) {
00166 __os<<"BasicRandom<double> : "<<_M_iseed[0]<<", "<<_M_iseed[1]<<std::endl;
00167 }
00168
00169 private:
00170 int _M_iseed[2];
00171 };
00172
00173
00174 extern BasicRandom<int> _G_random_int;
00175 extern BasicRandom<double> _G_random_double;
00176
00177
00178 FASTJET_END_NAMESPACE
00179
00180 #endif // __FASTJET_BASICRANDOM_HH__
00181