1/* { dg-do compile } */ 2/* { dg-options "-O2" } */ 3 4namespace std 5{ 6 template < class _T1, class _T2 > struct pair 7 { 8 }; 9} 10extern "C" 11{ 12 extern "C" 13 { 14 typedef int int32_t __attribute__ ((__mode__ (__SI__))); 15 struct _pthread_fastlock 16 { 17 } 18 pthread_mutexattr_t; 19 } 20} 21namespace std 22{ 23 struct __numeric_limits_base 24 { 25 }; 26 template < typename _Tp > 27 struct numeric_limits:public __numeric_limits_base 28 { 29 static const bool is_integer = true; 30 }; 31}; 32typedef unsigned int uint32_t; 33namespace std 34{ 35 template < typename _Alloc > class allocator; 36 template < class _CharT > struct char_traits; 37 template < typename _CharT, typename _Traits = 38 char_traits < _CharT >, typename _Alloc = 39 allocator < _CharT > >class basic_string; 40 typedef basic_string < char >string; 41} 42namespace __gnu_cxx 43{ 44 template < typename _Tp > class new_allocator 45 { 46 }; 47} 48namespace std 49{ 50 template < typename _Tp > class allocator:public __gnu_cxx::new_allocator < 51 _Tp > 52 { 53 }; 54 template < typename _CharT, typename _Traits, 55 typename _Alloc > class basic_string 56 { 57 public:inline basic_string (); 58 basic_string (const _CharT * __s, const _Alloc & __a = _Alloc ()); 59 }; 60} 61namespace boost 62{ 63 template < class T > class integer_traits:public std::numeric_limits < T > 64 { 65 }; 66 namespace detail 67 { 68 template < class T, T min_val, T max_val > class integer_traits_base 69 { 70 }; 71 } 72 template <> class integer_traits < int >:public std::numeric_limits < int >, 73 public detail::integer_traits_base < int, (-2147483647 - 1), 2147483647 > 74 { 75 }; 76 namespace random 77 { 78 template < class IntType, IntType m > class const_mod 79 { 80 public:static IntType add (IntType x, IntType c) 81 { 82 } 83 static IntType mult (IntType a, IntType x) 84 { 85 return mult_schrage (a, x); 86 } 87 static IntType mult_add (IntType a, IntType x, IntType c) 88 { 89 return add (mult (a, x), c); 90 } 91 static IntType mult_schrage (IntType a, IntType value) 92 { 93 for (;;) 94 { 95 if (value > 0) 96 break; 97 value += m; 98 } 99 } 100 }; 101 template < class IntType, IntType a, IntType c, IntType m, 102 IntType val > class linear_congruential 103 { 104 public:typedef IntType result_type; 105 static const IntType modulus = m; 106 explicit linear_congruential (IntType x0 = 1):_modulus (modulus), 107 _x (_modulus ? (x0 % _modulus) : 108 x0) 109 { 110 } 111 IntType operator () () 112 { 113 _x = const_mod < IntType, m >::mult_add (a, _x, c); 114 } 115 private:IntType _modulus; 116 IntType _x; 117 }; 118 } 119 typedef random::linear_congruential < int32_t, 16807, 0, 2147483647, 120 1043618065 > minstd_rand0; 121 namespace random 122 { 123 namespace detail 124 { 125 template < class T > struct ptr_helper 126 { 127 typedef T value_type; 128 typedef T & reference_type; 129 typedef const T & rvalue_type; 130 static reference_type ref (T & r) 131 { 132 } 133 }; 134 template < class T > struct ptr_helper <T & > 135 { 136 typedef T value_type; 137 typedef T & rvalue_type; 138 }; 139 } 140 } 141 template < class UniformRandomNumberGenerator, class RealType = 142 double >class uniform_01 143 { 144 public:typedef UniformRandomNumberGenerator base_type; 145 typedef RealType result_type; 146 explicit uniform_01 (base_type rng):_rng (rng), 147 _factor (result_type (1) / 148 (result_type ((_rng.max) () - (_rng.min) ()) + 149 result_type (std::numeric_limits < 150 base_result >::is_integer ? 1 : 0))) 151 { 152 } 153 result_type operator () () 154 { 155 return result_type (_rng () - (_rng.min) ()) * _factor; 156 } 157 private:typedef typename base_type::result_type base_result; 158 base_type _rng; 159 result_type _factor; 160 }; 161 namespace random 162 { 163 namespace detail 164 { 165 template < class UniformRandomNumberGenerator > 166 class pass_through_engine 167 { 168 private:typedef ptr_helper < UniformRandomNumberGenerator > 169 helper_type; 170 public:typedef typename helper_type::value_type base_type; 171 typedef typename base_type::result_type result_type; 172 explicit pass_through_engine (UniformRandomNumberGenerator 173 rng):_rng (static_cast < 174 typename helper_type:: 175 rvalue_type > (rng)) 176 { 177 } 178 result_type min () const 179 { 180 } 181 result_type max () const 182 { 183 } 184 base_type & base () 185 { 186 } 187 result_type operator () () 188 { 189 return base ()(); 190 } 191 private:UniformRandomNumberGenerator _rng; 192 }; 193 } 194 template < class RealType, int w, unsigned int p, 195 unsigned int q > class lagged_fibonacci_01 196 { 197 public:typedef RealType result_type; 198 static const unsigned int long_lag = p; 199 lagged_fibonacci_01 () 200 { 201 seed (); 202 } 203 public:void seed (uint32_t value = 331u) 204 { 205 minstd_rand0 intgen (value); 206 seed (intgen); 207 } 208 template < class Generator > void seed (Generator & gen) 209 { 210 typedef detail::pass_through_engine < Generator & >ref_gen; 211 uniform_01 < ref_gen, RealType > gen01 = 212 uniform_01 < ref_gen, RealType > (ref_gen (gen)); 213 for (unsigned int j = 0; j < long_lag; ++j) 214 x[j] = gen01 (); 215 } 216 RealType x[long_lag]; 217 }; 218 } 219 typedef random::lagged_fibonacci_01 < double, 48, 607, 220 273 > lagged_fibonacci607; 221 namespace random 222 { 223 namespace detail 224 { 225 template < bool have_int, bool want_int > struct engine_helper; 226 template <> struct engine_helper <true, true > 227 { 228 template < class Engine, class DistInputType > struct impl 229 { 230 typedef pass_through_engine < Engine > type; 231 }; 232 }; 233 } 234 } 235 template < class Engine, class Distribution > class variate_generator 236 { 237 private:typedef random::detail::pass_through_engine < Engine > 238 decorated_engine; 239 public:typedef typename decorated_engine::base_type engine_value_type; 240 typedef Distribution distribution_type; 241 variate_generator (Engine e, Distribution d):_eng (decorated_engine (e)), 242 _dist (d) 243 { 244 } 245 private:enum 246 { 247 have_int = 248 std::numeric_limits < 249 typename decorated_engine::result_type >::is_integer, want_int = 250 std::numeric_limits < typename Distribution::input_type >::is_integer 251 }; 252 typedef typename random::detail::engine_helper < have_int, 253 want_int >::template impl < decorated_engine, 254 typename Distribution::input_type >::type internal_engine_type; 255 internal_engine_type _eng; 256 distribution_type _dist; 257 }; 258 template < class RealType = double >class uniform_real 259 { 260 public:typedef RealType input_type; 261 }; 262} 263namespace alps 264{ 265 class BufferedRandomNumberGeneratorBase 266 { 267 }; 268 template < class RNG > 269 class BufferedRandomNumberGenerator:public 270 BufferedRandomNumberGeneratorBase 271 { 272 public: BufferedRandomNumberGenerator ():rng_ (), gen_ (rng_, 273 boost:: 274 uniform_real <> ()) 275 { 276 } 277 protected: RNG rng_; 278 boost::variate_generator < RNG &, boost::uniform_real <> >gen_; 279 }; 280} 281namespace boost 282{ 283 namespace detail 284 { 285 class sp_counted_base 286 { 287 }; 288 class shared_count 289 { 290 private:sp_counted_base * pi_; 291 public:shared_count ():pi_ (0) 292 { 293 } 294 template < class Y > explicit shared_count (Y * p):pi_ (0) 295 { 296 } 297 }; 298 } 299 template < class T > class shared_ptr 300 { 301 public:typedef T element_type; 302 template < class Y > explicit shared_ptr (Y * p):px (p), pn (p) 303 { 304 } 305 T *px; 306 detail::shared_count pn; 307 }; 308} 309namespace std 310{ 311 template < typename _Key, typename _Tp, typename _Compare = 312 std::allocator < std::pair < const _Key, _Tp > > > class map 313 { 314 public:typedef _Key key_type; 315 typedef _Tp mapped_type; 316 mapped_type & operator[] (const key_type & __k) 317 { 318 } 319 }; 320} 321namespace alps 322{ 323 namespace detail 324 { 325 template < class BASE > class abstract_creator 326 { 327 public:typedef BASE base_type; 328 virtual base_type *create () const = 0; 329 }; 330 template < class BASE, 331 class T > class creator:public abstract_creator < BASE > 332 { 333 public:typedef BASE base_type; 334 base_type *create () const 335 { 336 return new T (); 337 } 338 }; 339 } 340 template < class KEY, class BASE > class factory 341 { 342 public:typedef BASE base_type; 343 typedef KEY key_type; 344 typedef boost::shared_ptr < detail::abstract_creator < base_type > 345 >pointer_type; 346 template < class T > bool register_type (key_type k) 347 { 348 creators_[k] = pointer_type (new detail::creator < BASE, T > ()); 349 } 350 private:typedef std::map < key_type, pointer_type > map_type; 351 map_type creators_; 352 }; 353 class RNGFactory:public factory < std::string, 354 BufferedRandomNumberGeneratorBase > 355 { 356 public:RNGFactory (); 357 }; 358} 359alps::RNGFactory::RNGFactory () 360{ 361 register_type < BufferedRandomNumberGenerator < boost::lagged_fibonacci607 > 362 >("lagged_fibonacci607"); 363} 364