/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rocrand/checkouts/latest/library/include/rocrand/rocrand.hpp Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rocrand/checkouts/latest/library/include/rocrand/rocrand.hpp Source File#

API library: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rocrand/checkouts/latest/library/include/rocrand/rocrand.hpp Source File
rocrand.hpp
1 // Copyright (c) 2017-2024 Advanced Micro Devices, Inc. All rights reserved.
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in
11 // all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 // THE SOFTWARE.
20 
21 #ifndef ROCRAND_HPP_
22 #define ROCRAND_HPP_
23 
24 // At least C++11 required
25 #if defined(__cplusplus) && __cplusplus >= 201103L
26 
27  #include "rocrand/rocrand.h"
28  #include "rocrand/rocrand_kernel.h"
29 
30  #include <exception>
31  #include <limits>
32  #include <random>
33  #include <sstream>
34  #include <string>
35  #include <type_traits>
36 
37  #include <cassert>
38 
39 namespace rocrand_cpp {
40 
43 
49 class error : public std::exception
50 {
51 public:
53  typedef rocrand_status error_type;
54 
58  explicit error(error_type error) noexcept
59  : m_error(error),
60  m_error_string(to_string(error))
61  {
62  }
63 
65  error_type error_code() const noexcept
66  {
67  return m_error;
68  }
69 
71  std::string error_string() const noexcept
72  {
73  return m_error_string;
74  }
75 
77  const char* what() const noexcept override
78  {
79  return m_error_string.c_str();
80  }
81 
88  static std::string to_string(error_type error)
89  {
90  switch(error)
91  {
92  case ROCRAND_STATUS_SUCCESS:
93  return "Success";
94  case ROCRAND_STATUS_VERSION_MISMATCH:
95  return "Header file and linked library version do not match";
96  case ROCRAND_STATUS_NOT_CREATED:
97  return "Generator was not created using rocrand_create_generator";
98  case ROCRAND_STATUS_ALLOCATION_FAILED:
99  return "Memory allocation failed during execution";
100  case ROCRAND_STATUS_TYPE_ERROR:
101  return "Generator type is wrong";
102  case ROCRAND_STATUS_OUT_OF_RANGE:
103  return "Argument out of range";
104  case ROCRAND_STATUS_LENGTH_NOT_MULTIPLE:
105  return "Length requested is not a multiple of dimension";
106  case ROCRAND_STATUS_DOUBLE_PRECISION_REQUIRED:
107  return "GPU does not have double precision";
108  case ROCRAND_STATUS_LAUNCH_FAILURE:
109  return "Kernel launch failure";
110  case ROCRAND_STATUS_INTERNAL_ERROR:
111  return "Internal library error";
112  default: {
113  std::stringstream s;
114  s << "Unknown rocRAND error (" << error << ")";
115  return s.str();
116  }
117  }
118  }
119 
121  friend
122  bool operator==(const error& l, const error& r)
123  {
124  return l.error_code() == r.error_code();
125  }
126 
128  friend
129  bool operator!=(const error& l, const error& r)
130  {
131  return !(l == r);
132  }
133 
134 private:
135  error_type m_error;
136  std::string m_error_string;
137 };
138 
144 template<class IntType = unsigned int>
145 class uniform_int_distribution
146 {
147  static_assert(std::is_same<unsigned char, IntType>::value
148  || std::is_same<unsigned short, IntType>::value
149  || std::is_same<unsigned long long int, IntType>::value
150  || std::is_same<unsigned int, IntType>::value,
151  "Only unsigned char, unsigned short, unsigned int and unsigned long long int "
152  "types are supported in uniform_int_distribution");
153 
154 public:
156  typedef IntType result_type;
157 
159  uniform_int_distribution()
160  {
161  }
162 
164  static void reset()
165  {
166  }
167 
169  static constexpr IntType min()
170  {
171  return 0;
172  }
173 
175  static constexpr IntType max()
176  {
177  return std::numeric_limits<IntType>::max();
178  }
179 
197  template<class Generator>
198  void operator()(Generator& g, IntType * output, size_t size)
199  {
200  rocrand_status status;
201  status = this->generate(g, output, size);
202  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
203  }
204 
206  bool operator==(const uniform_int_distribution<IntType>& other) const
207  {
208  (void) other;
209  return true;
210  }
211 
213  bool operator!=(const uniform_int_distribution<IntType>& other) const
214  {
215  return !(*this == other);
216  }
217 
218 private:
219  template<class Generator>
220  static rocrand_status generate(Generator& g, unsigned char * output, size_t size)
221  {
222  return rocrand_generate_char(g.m_generator, output, size);
223  }
224 
225  template<class Generator>
226  static rocrand_status generate(Generator& g, unsigned short * output, size_t size)
227  {
228  return rocrand_generate_short(g.m_generator, output, size);
229  }
230 
231  template<class Generator>
232  static rocrand_status generate(Generator& g, unsigned int * output, size_t size)
233  {
234  return rocrand_generate(g.m_generator, output, size);
235  }
236 
237  template<class Generator>
238  static rocrand_status generate(Generator& g, unsigned long long int* output, size_t size)
239  {
240  return rocrand_generate_long_long(g.m_generator, output, size);
241  }
242 };
243 
249 
250 template<class RealType = float>
251 class uniform_real_distribution
252 {
253  static_assert(
254  std::is_same<float, RealType>::value
255  || std::is_same<double, RealType>::value
256  || std::is_same<half, RealType>::value,
257  "Only float, double, and half types are supported in uniform_real_distribution"
258  );
259 
260 public:
262  typedef RealType result_type;
263 
265  uniform_real_distribution()
266  {
267  }
268 
270  static void reset()
271  {
272  }
273 
275  static constexpr RealType min()
276  {
277  return static_cast<RealType>(ROCRAND_2POW32_INV_DOUBLE);
278  }
279 
281  static constexpr RealType max()
282  {
283  return 1.0;
284  }
285 
303  template<class Generator>
304  void operator()(Generator& g, RealType * output, size_t size)
305  {
306  rocrand_status status;
307  status = this->generate(g, output, size);
308  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
309  }
310 
312  bool operator==(const uniform_real_distribution<RealType>& other) const
313  {
314  (void) other;
315  return true;
316  }
317 
319  bool operator!=(const uniform_real_distribution<RealType>& other) const
320  {
321  return !(*this == other);
322  }
323 
324 private:
325  template<class Generator>
326  static rocrand_status generate(Generator& g, float * output, size_t size)
327  {
328  return rocrand_generate_uniform(g.m_generator, output, size);
329  }
330 
331  template<class Generator>
332  static rocrand_status generate(Generator& g, double * output, size_t size)
333  {
334  return rocrand_generate_uniform_double(g.m_generator, output, size);
335  }
336 
337  template<class Generator>
338  static rocrand_status generate(Generator& g, half * output, size_t size)
339  {
340  return rocrand_generate_uniform_half(g.m_generator, output, size);
341  }
342 };
343 
349 template<class RealType = float>
350 class normal_distribution
351 {
352  static_assert(
353  std::is_same<float, RealType>::value
354  || std::is_same<double, RealType>::value
355  || std::is_same<half, RealType>::value,
356  "Only float, double and half types are supported in normal_distribution"
357  );
358 
359 public:
361  typedef RealType result_type;
362 
365  class param_type
366  {
367  public:
369  using distribution_type = normal_distribution<RealType>;
370 
375  param_type(RealType mean = 0.0, RealType stddev = 1.0)
376  : m_mean(mean), m_stddev(stddev)
377  {
378  }
379 
381  param_type(const param_type& params) = default;
382 
384  param_type& operator=(const param_type& params) = default;
385 
389  RealType mean() const
390  {
391  return m_mean;
392  }
393 
397  RealType stddev() const
398  {
399  return m_stddev;
400  }
401 
403  bool operator==(const param_type& other) const
404  {
405  return m_mean == other.m_mean && m_stddev == other.m_stddev;
406  }
407 
409  bool operator!=(const param_type& other) const
410  {
411  return !(*this == other);
412  }
413  private:
414  RealType m_mean;
415  RealType m_stddev;
416  };
417 
421  normal_distribution(RealType mean = 0.0, RealType stddev = 1.0)
422  : m_params(mean, stddev)
423  {
424  }
425 
428  explicit normal_distribution(const param_type& params)
429  : m_params(params)
430  {
431  }
432 
434  static void reset()
435  {
436  }
437 
441  RealType mean() const
442  {
443  return m_params.mean();
444  }
445 
449  RealType stddev() const
450  {
451  return m_params.stddev();
452  }
453 
455  static constexpr RealType min()
456  {
457  return std::numeric_limits<RealType>::lowest();
458  }
459 
461  static constexpr RealType max()
462  {
463  return std::numeric_limits<RealType>::max();
464  }
465 
467  param_type param() const
468  {
469  return m_params;
470  }
471 
473  void param(const param_type& params)
474  {
475  m_params = params;
476  }
477 
496  template<class Generator>
497  void operator()(Generator& g, RealType * output, size_t size)
498  {
499  rocrand_status status;
500  status = this->generate(g, output, size);
501  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
502  }
503 
507  bool operator==(const normal_distribution<RealType>& other) const
508  {
509  return this->m_params == other.m_params;
510  }
511 
515  bool operator!=(const normal_distribution<RealType>& other) const
516  {
517  return !(*this == other);
518  }
519 
520 private:
521  template<class Generator>
522  rocrand_status generate(Generator& g, float * output, size_t size)
523  {
524  return rocrand_generate_normal(
525  g.m_generator, output, size, this->mean(), this->stddev()
526  );
527  }
528 
529  template<class Generator>
530  rocrand_status generate(Generator& g, double * output, size_t size)
531  {
532  return rocrand_generate_normal_double(
533  g.m_generator, output, size, this->mean(), this->stddev()
534  );
535  }
536 
537  template<class Generator>
538  rocrand_status generate(Generator& g, half * output, size_t size)
539  {
540  return rocrand_generate_normal_half(
541  g.m_generator, output, size, this->mean(), this->stddev()
542  );
543  }
544 
545  param_type m_params;
546 };
547 
553 template<class RealType = float>
554 class lognormal_distribution
555 {
556  static_assert(
557  std::is_same<float, RealType>::value
558  || std::is_same<double, RealType>::value
559  || std::is_same<half, RealType>::value,
560  "Only float, double and half types are supported in lognormal_distribution"
561  );
562 
563 public:
565  typedef RealType result_type;
566 
569  class param_type
570  {
571  public:
573  using distribution_type = lognormal_distribution<RealType>;
574 
579  param_type(RealType m = 0.0, RealType s = 1.0)
580  : m_mean(m), m_stddev(s)
581  {
582  }
583 
585  param_type(const param_type& params) = default;
586 
588  param_type& operator=(const param_type& params) = default;
589 
593  RealType m() const
594  {
595  return m_mean;
596  }
597 
601  RealType s() const
602  {
603  return m_stddev;
604  }
605 
607  bool operator==(const param_type& other) const
608  {
609  return m_mean == other.m_mean && m_stddev == other.m_stddev;
610  }
611 
613  bool operator!=(const param_type& other) const
614  {
615  return !(*this == other);
616  }
617  private:
618  RealType m_mean;
619  RealType m_stddev;
620  };
621 
625  lognormal_distribution(RealType m = 0.0, RealType s = 1.0)
626  : m_params(m, s)
627  {
628  }
629 
632  explicit lognormal_distribution(const param_type& params)
633  : m_params(params)
634  {
635  }
636 
638  static void reset()
639  {
640  }
641 
645  RealType m() const
646  {
647  return m_params.m();
648  }
649 
653  RealType s() const
654  {
655  return m_params.s();
656  }
657 
659  param_type param() const
660  {
661  return m_params;
662  }
663 
665  void param(const param_type& params)
666  {
667  m_params = params;
668  }
669 
671  static constexpr RealType min()
672  {
673  return 0;
674  }
675 
677  static RealType max()
678  {
679  return std::numeric_limits<RealType>::max();
680  }
681 
701  template<class Generator>
702  void operator()(Generator& g, RealType * output, size_t size)
703  {
704  rocrand_status status;
705  status = this->generate(g, output, size);
706  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
707  }
708 
712  bool operator==(const lognormal_distribution<RealType>& other) const
713  {
714  return this->m_params == other.m_params;
715  }
716 
720  bool operator!=(const lognormal_distribution<RealType>& other) const
721  {
722  return !(*this == other);
723  }
724 
725 private:
726  template<class Generator>
727  rocrand_status generate(Generator& g, float * output, size_t size)
728  {
729  return rocrand_generate_log_normal(
730  g.m_generator, output, size, this->m(), this->s()
731  );
732  }
733 
734  template<class Generator>
735  rocrand_status generate(Generator& g, double * output, size_t size)
736  {
737  return rocrand_generate_log_normal_double(
738  g.m_generator, output, size, this->m(), this->s()
739  );
740  }
741 
742  template<class Generator>
743  rocrand_status generate(Generator& g, half * output, size_t size)
744  {
745  return rocrand_generate_log_normal_half(
746  g.m_generator, output, size, this->m(), this->s()
747  );
748  }
749 
750  param_type m_params;
751 };
752 
758 template<class IntType = unsigned int>
759 class poisson_distribution
760 {
761  static_assert(
762  std::is_same<unsigned int, IntType>::value,
763  "Only unsigned int type is supported in poisson_distribution"
764  );
765 
766 public:
768  typedef IntType result_type;
769 
772  class param_type
773  {
774  public:
776  using distribution_type = poisson_distribution<IntType>;
777 
781  param_type(double mean = 1.0)
782  : m_mean(mean)
783  {
784  }
785 
787  param_type(const param_type& params) = default;
788 
790  param_type& operator=(const param_type& params) = default;
791 
796  double mean() const
797  {
798  return m_mean;
799  }
800 
802  bool operator==(const param_type& other) const
803  {
804  return m_mean == other.m_mean;
805  }
806 
808  bool operator!=(const param_type& other) const
809  {
810  return !(*this == other);
811  }
812 
813  private:
814  double m_mean;
815  };
816 
819  poisson_distribution(double mean = 1.0)
820  : m_params(mean)
821  {
822  }
823 
826  explicit poisson_distribution(const param_type& params)
827  : m_params(params)
828  {
829  }
830 
832  static void reset()
833  {
834  }
835 
840  double mean() const
841  {
842  return m_params.mean();
843  }
844 
846  static constexpr IntType min()
847  {
848  return 0;
849  }
850 
852  static constexpr IntType max()
853  {
854  return std::numeric_limits<IntType>::max();
855  }
856 
858  param_type param()
859  {
860  return m_params;
861  }
862 
864  void param(const param_type& params)
865  {
866  m_params = params;
867  }
868 
887  template<class Generator>
888  void operator()(Generator& g, IntType * output, size_t size)
889  {
890  rocrand_status status;
891  status = rocrand_generate_poisson(g.m_generator, output, size, this->mean());
892  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
893  }
894 
898  bool operator==(const poisson_distribution<IntType>& other) const
899  {
900  return this->m_params == other.m_params;
901  }
902 
906  bool operator!=(const poisson_distribution<IntType>& other) const
907  {
908  return !(*this == other);
909  }
910 
911 private:
912  param_type m_params;
913 };
914 
919 template<unsigned long long DefaultSeed = ROCRAND_PHILOX4x32_DEFAULT_SEED>
920 class philox4x32_10_engine
921 {
922 public:
925  typedef unsigned int result_type;
926  // \typedef order_type
931  typedef rocrand_ordering order_type;
938  typedef unsigned long long offset_type;
943  typedef unsigned long long seed_type;
945  static constexpr seed_type default_seed = DefaultSeed;
946 
954  philox4x32_10_engine(seed_type seed_value = DefaultSeed,
955  offset_type offset_value = 0,
956  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
957  {
958  rocrand_status status;
959  status = rocrand_create_generator(&m_generator, this->type());
960  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
961  try
962  {
963  if(offset_value > 0)
964  {
965  this->offset(offset_value);
966  }
967  this->order(order_value);
968  this->seed(seed_value);
969  }
970  catch(...)
971  {
972  (void)rocrand_destroy_generator(m_generator);
973  throw;
974  }
975  }
976 
985  explicit philox4x32_10_engine(rocrand_generator& generator)
986  : m_generator(generator)
987  {
988  if(generator == NULL)
989  {
990  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
991  }
992  generator = NULL;
993  }
994 
995  philox4x32_10_engine(const philox4x32_10_engine&) = delete;
996 
997  philox4x32_10_engine& operator=(const philox4x32_10_engine&) = delete;
998 
1005  philox4x32_10_engine(philox4x32_10_engine&& rhs) noexcept : m_generator(rhs.m_generator)
1006  {
1007  rhs.m_generator = nullptr;
1008  }
1009 
1016  philox4x32_10_engine& operator=(philox4x32_10_engine&& rhs) noexcept
1017  {
1018  rocrand_status status = rocrand_destroy_generator(m_generator);
1019  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
1020  (void)status;
1021 
1022  m_generator = rhs.m_generator;
1023  rhs.m_generator = nullptr;
1024  return *this;
1025  }
1026 
1030  ~philox4x32_10_engine() noexcept(false)
1031  {
1032  rocrand_status status = rocrand_destroy_generator(m_generator);
1033  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
1034  throw rocrand_cpp::error(status);
1035  }
1036 
1039  void stream(hipStream_t value)
1040  {
1041  rocrand_status status = rocrand_set_stream(m_generator, value);
1042  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1043  }
1044 
1056  void order(order_type value)
1057  {
1058  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
1059  if(status != ROCRAND_STATUS_SUCCESS)
1060  throw rocrand_cpp::error(status);
1061  }
1062 
1074  void offset(offset_type value)
1075  {
1076  rocrand_status status = rocrand_set_offset(this->m_generator, value);
1077  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1078  }
1079 
1090  void seed(seed_type value)
1091  {
1092  rocrand_status status = rocrand_set_seed(this->m_generator, value);
1093  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1094  }
1095 
1109  template<class Generator>
1110  void operator()(result_type * output, size_t size)
1111  {
1112  rocrand_status status;
1113  status = rocrand_generate(m_generator, output, size);
1114  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1115  }
1116 
1118  static constexpr result_type min()
1119  {
1120  return 0;
1121  }
1122 
1124  static constexpr result_type max()
1125  {
1126  return std::numeric_limits<unsigned int>::max();
1127  }
1128 
1130  static constexpr rocrand_rng_type type()
1131  {
1132  return ROCRAND_RNG_PSEUDO_PHILOX4_32_10;
1133  }
1134 
1135 private:
1136  rocrand_generator m_generator;
1137 
1139  template<class T>
1140  friend class ::rocrand_cpp::uniform_int_distribution;
1141 
1142  template<class T>
1143  friend class ::rocrand_cpp::uniform_real_distribution;
1144 
1145  template<class T>
1146  friend class ::rocrand_cpp::normal_distribution;
1147 
1148  template<class T>
1149  friend class ::rocrand_cpp::lognormal_distribution;
1150 
1151  template<class T>
1152  friend class ::rocrand_cpp::poisson_distribution;
1154 };
1155 
1157 template<unsigned long long DefaultSeed>
1158 constexpr typename philox4x32_10_engine<DefaultSeed>::seed_type philox4x32_10_engine<DefaultSeed>::default_seed;
1160 
1166 template<unsigned long long DefaultSeed = ROCRAND_XORWOW_DEFAULT_SEED>
1167 class xorwow_engine
1168 {
1169 public:
1171  typedef unsigned int result_type;
1173  typedef rocrand_ordering order_type;
1175  typedef unsigned long long offset_type;
1177  typedef unsigned long long seed_type;
1179  static constexpr seed_type default_seed = DefaultSeed;
1180 
1182  xorwow_engine(seed_type seed_value = DefaultSeed,
1183  offset_type offset_value = 0,
1184  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
1185  {
1186  rocrand_status status;
1187  status = rocrand_create_generator(&m_generator, this->type());
1188  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1189  try
1190  {
1191  this->order(order_value);
1192  if(offset_value > 0)
1193  {
1194  this->offset(offset_value);
1195  }
1196  this->seed(seed_value);
1197  }
1198  catch(...)
1199  {
1200  (void)rocrand_destroy_generator(m_generator);
1201  throw;
1202  }
1203  }
1204 
1206  explicit xorwow_engine(rocrand_generator& generator)
1207  : m_generator(generator)
1208  {
1209  if(generator == NULL)
1210  {
1211  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
1212  }
1213  generator = NULL;
1214  }
1215 
1216  xorwow_engine(const xorwow_engine&) = delete;
1217 
1218  xorwow_engine& operator=(const xorwow_engine&) = delete;
1219 
1221  xorwow_engine(xorwow_engine&& rhs) noexcept : m_generator(rhs.m_generator)
1222  {
1223  rhs.m_generator = nullptr;
1224  }
1225 
1227  xorwow_engine& operator=(xorwow_engine&& rhs) noexcept
1228  {
1229  rocrand_status status = rocrand_destroy_generator(m_generator);
1230  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
1231  (void)status;
1232 
1233  m_generator = rhs.m_generator;
1234  rhs.m_generator = nullptr;
1235  return *this;
1236  }
1237 
1239  ~xorwow_engine() noexcept(false)
1240  {
1241  rocrand_status status = rocrand_destroy_generator(m_generator);
1242  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
1243  throw rocrand_cpp::error(status);
1244  }
1245 
1247  void stream(hipStream_t value)
1248  {
1249  rocrand_status status = rocrand_set_stream(m_generator, value);
1250  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1251  }
1252 
1254  void order(order_type value)
1255  {
1256  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
1257  if(status != ROCRAND_STATUS_SUCCESS)
1258  throw rocrand_cpp::error(status);
1259  }
1260 
1262  void offset(offset_type value)
1263  {
1264  rocrand_status status = rocrand_set_offset(this->m_generator, value);
1265  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1266  }
1267 
1269  void seed(seed_type value)
1270  {
1271  rocrand_status status = rocrand_set_seed(this->m_generator, value);
1272  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1273  }
1274 
1276  template<class Generator>
1277  void operator()(result_type * output, size_t size)
1278  {
1279  rocrand_status status;
1280  status = rocrand_generate(m_generator, output, size);
1281  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1282  }
1283 
1285  static constexpr result_type min()
1286  {
1287  return 0;
1288  }
1289 
1291  static constexpr result_type max()
1292  {
1293  return std::numeric_limits<unsigned int>::max();
1294  }
1295 
1297  static constexpr rocrand_rng_type type()
1298  {
1299  return ROCRAND_RNG_PSEUDO_XORWOW;
1300  }
1301 
1302 private:
1303  rocrand_generator m_generator;
1304 
1306  template<class T>
1307  friend class ::rocrand_cpp::uniform_int_distribution;
1308 
1309  template<class T>
1310  friend class ::rocrand_cpp::uniform_real_distribution;
1311 
1312  template<class T>
1313  friend class ::rocrand_cpp::normal_distribution;
1314 
1315  template<class T>
1316  friend class ::rocrand_cpp::lognormal_distribution;
1317 
1318  template<class T>
1319  friend class ::rocrand_cpp::poisson_distribution;
1321 };
1322 
1324 template<unsigned long long DefaultSeed>
1325 constexpr typename xorwow_engine<DefaultSeed>::seed_type xorwow_engine<DefaultSeed>::default_seed;
1327 
1333 template<unsigned long long DefaultSeed = ROCRAND_MRG31K3P_DEFAULT_SEED>
1334 class mrg31k3p_engine
1335 {
1336 public:
1338  typedef unsigned int result_type;
1340  typedef rocrand_ordering order_type;
1342  typedef unsigned long long offset_type;
1344  typedef unsigned long long seed_type;
1346  static constexpr seed_type default_seed = DefaultSeed;
1347 
1349  mrg31k3p_engine(seed_type seed_value = DefaultSeed,
1350  offset_type offset_value = 0,
1351  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
1352  {
1353  rocrand_status status;
1354  status = rocrand_create_generator(&m_generator, this->type());
1355  if(status != ROCRAND_STATUS_SUCCESS)
1356  throw rocrand_cpp::error(status);
1357  try
1358  {
1359  this->order(order_value);
1360  if(offset_value > 0)
1361  {
1362  this->offset(offset_value);
1363  }
1364  this->seed(seed_value);
1365  }
1366  catch(...)
1367  {
1368  (void)rocrand_destroy_generator(m_generator);
1369  throw;
1370  }
1371  }
1372 
1374  explicit mrg31k3p_engine(rocrand_generator& generator) : m_generator(generator)
1375  {
1376  if(generator == NULL)
1377  {
1378  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
1379  }
1380  generator = NULL;
1381  }
1382 
1383  mrg31k3p_engine(const mrg31k3p_engine&) = delete;
1384 
1385  mrg31k3p_engine& operator=(const mrg31k3p_engine&) = delete;
1386 
1388  mrg31k3p_engine(mrg31k3p_engine&& rhs) noexcept : m_generator(rhs.m_generator)
1389  {
1390  rhs.m_generator = nullptr;
1391  }
1392 
1394  mrg31k3p_engine& operator=(mrg31k3p_engine&& rhs) noexcept
1395  {
1396  rocrand_status status = rocrand_destroy_generator(m_generator);
1397  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
1398  (void)status;
1399 
1400  m_generator = rhs.m_generator;
1401  rhs.m_generator = nullptr;
1402  return *this;
1403  }
1404 
1406  ~mrg31k3p_engine() noexcept(false)
1407  {
1408  rocrand_status status = rocrand_destroy_generator(m_generator);
1409  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
1410  throw rocrand_cpp::error(status);
1411  }
1412 
1414  void stream(hipStream_t value)
1415  {
1416  rocrand_status status = rocrand_set_stream(m_generator, value);
1417  if(status != ROCRAND_STATUS_SUCCESS)
1418  throw rocrand_cpp::error(status);
1419  }
1420 
1422  void order(order_type value)
1423  {
1424  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
1425  if(status != ROCRAND_STATUS_SUCCESS)
1426  throw rocrand_cpp::error(status);
1427  }
1428 
1430  void offset(offset_type value)
1431  {
1432  rocrand_status status = rocrand_set_offset(this->m_generator, value);
1433  if(status != ROCRAND_STATUS_SUCCESS)
1434  throw rocrand_cpp::error(status);
1435  }
1436 
1438  void seed(seed_type value)
1439  {
1440  rocrand_status status = rocrand_set_seed(this->m_generator, value);
1441  if(status != ROCRAND_STATUS_SUCCESS)
1442  throw rocrand_cpp::error(status);
1443  }
1444 
1446  template<class Generator>
1447  void operator()(result_type* output, size_t size)
1448  {
1449  rocrand_status status;
1450  status = rocrand_generate(m_generator, output, size);
1451  if(status != ROCRAND_STATUS_SUCCESS)
1452  throw rocrand_cpp::error(status);
1453  }
1454 
1456  static constexpr result_type min()
1457  {
1458  return 1;
1459  }
1460 
1462  static constexpr result_type max()
1463  {
1464  return std::numeric_limits<unsigned int>::max();
1465  }
1466 
1468  static constexpr rocrand_rng_type type()
1469  {
1470  return ROCRAND_RNG_PSEUDO_MRG31K3P;
1471  }
1472 
1473 private:
1474  rocrand_generator m_generator;
1475 
1477  template<class T>
1478  friend class ::rocrand_cpp::uniform_int_distribution;
1479 
1480  template<class T>
1481  friend class ::rocrand_cpp::uniform_real_distribution;
1482 
1483  template<class T>
1484  friend class ::rocrand_cpp::normal_distribution;
1485 
1486  template<class T>
1487  friend class ::rocrand_cpp::lognormal_distribution;
1488 
1489  template<class T>
1490  friend class ::rocrand_cpp::poisson_distribution;
1492 };
1493 
1495 template<unsigned long long DefaultSeed>
1496 constexpr
1497  typename mrg31k3p_engine<DefaultSeed>::seed_type mrg31k3p_engine<DefaultSeed>::default_seed;
1499 
1505 template<unsigned long long DefaultSeed = ROCRAND_MRG32K3A_DEFAULT_SEED>
1506 class mrg32k3a_engine
1507 {
1508 public:
1510  typedef unsigned int result_type;
1512  typedef rocrand_ordering order_type;
1514  typedef unsigned long long offset_type;
1516  typedef unsigned long long seed_type;
1518  static constexpr seed_type default_seed = DefaultSeed;
1519 
1521  mrg32k3a_engine(seed_type seed_value = DefaultSeed,
1522  offset_type offset_value = 0,
1523  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
1524  {
1525  rocrand_status status;
1526  status = rocrand_create_generator(&m_generator, this->type());
1527  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1528  try
1529  {
1530  this->order(order_value);
1531  if(offset_value > 0)
1532  {
1533  this->offset(offset_value);
1534  }
1535  this->seed(seed_value);
1536  }
1537  catch(...)
1538  {
1539  (void)rocrand_destroy_generator(m_generator);
1540  throw;
1541  }
1542  }
1543 
1545  explicit mrg32k3a_engine(rocrand_generator& generator)
1546  : m_generator(generator)
1547  {
1548  if(generator == NULL)
1549  {
1550  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
1551  }
1552  generator = NULL;
1553  }
1554 
1555  mrg32k3a_engine(const mrg32k3a_engine&) = delete;
1556 
1557  mrg32k3a_engine& operator=(const mrg32k3a_engine&) = delete;
1558 
1560  mrg32k3a_engine(mrg32k3a_engine&& rhs) noexcept : m_generator(rhs.m_generator)
1561  {
1562  rhs.m_generator = nullptr;
1563  }
1564 
1566  mrg32k3a_engine& operator=(mrg32k3a_engine&& rhs) noexcept
1567  {
1568  rocrand_status status = rocrand_destroy_generator(m_generator);
1569  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
1570  (void)status;
1571 
1572  m_generator = rhs.m_generator;
1573  rhs.m_generator = nullptr;
1574  return *this;
1575  }
1576 
1578  ~mrg32k3a_engine() noexcept(false)
1579  {
1580  rocrand_status status = rocrand_destroy_generator(m_generator);
1581  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
1582  throw rocrand_cpp::error(status);
1583  }
1584 
1586  void stream(hipStream_t value)
1587  {
1588  rocrand_status status = rocrand_set_stream(m_generator, value);
1589  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1590  }
1591 
1593  void order(order_type value)
1594  {
1595  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
1596  if(status != ROCRAND_STATUS_SUCCESS)
1597  throw rocrand_cpp::error(status);
1598  }
1599 
1601  void offset(offset_type value)
1602  {
1603  rocrand_status status = rocrand_set_offset(this->m_generator, value);
1604  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1605  }
1606 
1608  void seed(seed_type value)
1609  {
1610  rocrand_status status = rocrand_set_seed(this->m_generator, value);
1611  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1612  }
1613 
1615  template<class Generator>
1616  void operator()(result_type * output, size_t size)
1617  {
1618  rocrand_status status;
1619  status = rocrand_generate(m_generator, output, size);
1620  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1621  }
1622 
1624  static constexpr result_type min()
1625  {
1626  return 1;
1627  }
1628 
1630  static constexpr result_type max()
1631  {
1632  return std::numeric_limits<unsigned int>::max();
1633  }
1634 
1636  static constexpr rocrand_rng_type type()
1637  {
1638  return ROCRAND_RNG_PSEUDO_MRG32K3A;
1639  }
1640 
1641 private:
1642  rocrand_generator m_generator;
1643 
1645  template<class T>
1646  friend class ::rocrand_cpp::uniform_int_distribution;
1647 
1648  template<class T>
1649  friend class ::rocrand_cpp::uniform_real_distribution;
1650 
1651  template<class T>
1652  friend class ::rocrand_cpp::normal_distribution;
1653 
1654  template<class T>
1655  friend class ::rocrand_cpp::lognormal_distribution;
1656 
1657  template<class T>
1658  friend class ::rocrand_cpp::poisson_distribution;
1660 };
1661 
1663 template<unsigned long long DefaultSeed>
1664 constexpr typename mrg32k3a_engine<DefaultSeed>::seed_type mrg32k3a_engine<DefaultSeed>::default_seed;
1666 
1673 template<unsigned long long DefaultSeed = 0>
1674 class mtgp32_engine
1675 {
1676 public:
1678  typedef unsigned int result_type;
1680  typedef rocrand_ordering order_type;
1682  typedef unsigned long long offset_type;
1684  typedef unsigned long long seed_type;
1686  static constexpr seed_type default_seed = DefaultSeed;
1687 
1696  mtgp32_engine(seed_type seed_value = DefaultSeed,
1697  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
1698  {
1699  rocrand_status status;
1700  status = rocrand_create_generator(&m_generator, this->type());
1701  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1702  try
1703  {
1704  this->order(order_value);
1705  this->seed(seed_value);
1706  }
1707  catch(...)
1708  {
1709  (void)rocrand_destroy_generator(m_generator);
1710  throw;
1711  }
1712  }
1713 
1715  explicit mtgp32_engine(rocrand_generator& generator)
1716  : m_generator(generator)
1717  {
1718  if(generator == NULL)
1719  {
1720  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
1721  }
1722  generator = NULL;
1723  }
1724 
1725  mtgp32_engine(const mtgp32_engine&) = delete;
1726 
1727  mtgp32_engine& operator=(const mtgp32_engine&) = delete;
1728 
1730  mtgp32_engine(mtgp32_engine&& rhs) noexcept : m_generator(rhs.m_generator)
1731  {
1732  rhs.m_generator = nullptr;
1733  }
1734 
1736  mtgp32_engine& operator=(mtgp32_engine&& rhs) noexcept
1737  {
1738  rocrand_status status = rocrand_destroy_generator(m_generator);
1739  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
1740  (void)status;
1741 
1742  m_generator = rhs.m_generator;
1743  rhs.m_generator = nullptr;
1744  return *this;
1745  }
1746 
1748  ~mtgp32_engine() noexcept(false)
1749  {
1750  rocrand_status status = rocrand_destroy_generator(m_generator);
1751  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
1752  throw rocrand_cpp::error(status);
1753  }
1754 
1756  void stream(hipStream_t value)
1757  {
1758  rocrand_status status = rocrand_set_stream(m_generator, value);
1759  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1760  }
1761 
1763  void order(order_type value)
1764  {
1765  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
1766  if(status != ROCRAND_STATUS_SUCCESS)
1767  throw rocrand_cpp::error(status);
1768  }
1769 
1771  void seed(seed_type value)
1772  {
1773  rocrand_status status = rocrand_set_seed(this->m_generator, value);
1774  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1775  }
1776 
1778  template<class Generator>
1779  void operator()(result_type * output, size_t size)
1780  {
1781  rocrand_status status;
1782  status = rocrand_generate(m_generator, output, size);
1783  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
1784  }
1785 
1787  static constexpr result_type min()
1788  {
1789  return 0;
1790  }
1791 
1793  static constexpr result_type max()
1794  {
1795  return std::numeric_limits<unsigned int>::max();
1796  }
1797 
1799  static constexpr rocrand_rng_type type()
1800  {
1801  return ROCRAND_RNG_PSEUDO_MTGP32;
1802  }
1803 
1804 private:
1805  rocrand_generator m_generator;
1806 
1808  template<class T>
1809  friend class ::rocrand_cpp::uniform_int_distribution;
1810 
1811  template<class T>
1812  friend class ::rocrand_cpp::uniform_real_distribution;
1813 
1814  template<class T>
1815  friend class ::rocrand_cpp::normal_distribution;
1816 
1817  template<class T>
1818  friend class ::rocrand_cpp::lognormal_distribution;
1819 
1820  template<class T>
1821  friend class ::rocrand_cpp::poisson_distribution;
1823 };
1824 
1826 template<unsigned long long DefaultSeed>
1827 constexpr typename mtgp32_engine<DefaultSeed>::seed_type mtgp32_engine<DefaultSeed>::default_seed;
1829 
1835 template<unsigned int DefaultSeedX = ROCRAND_LFSR113_DEFAULT_SEED_X,
1836  unsigned int DefaultSeedY = ROCRAND_LFSR113_DEFAULT_SEED_Y,
1837  unsigned int DefaultSeedZ = ROCRAND_LFSR113_DEFAULT_SEED_Z,
1838  unsigned int DefaultSeedW = ROCRAND_LFSR113_DEFAULT_SEED_W>
1839 class lfsr113_engine
1840 {
1841 public:
1843  typedef unsigned int result_type;
1845  typedef rocrand_ordering order_type;
1847  typedef uint4 seed_type;
1849  static constexpr seed_type default_seed
1850  = {DefaultSeedX, DefaultSeedY, DefaultSeedZ, DefaultSeedW};
1851 
1860  lfsr113_engine(seed_type seed_value = {DefaultSeedX, DefaultSeedY, DefaultSeedZ, DefaultSeedW},
1861  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
1862  {
1863  rocrand_status status;
1864  status = rocrand_create_generator(&m_generator, this->type());
1865  if(status != ROCRAND_STATUS_SUCCESS)
1866  throw rocrand_cpp::error(status);
1867  try
1868  {
1869  this->order(order_value);
1870  this->seed(seed_value);
1871  }
1872  catch(...)
1873  {
1874  (void)rocrand_destroy_generator(m_generator);
1875  throw;
1876  }
1877  }
1878 
1880  lfsr113_engine(unsigned long long seed_value,
1881  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
1882  {
1883  rocrand_status status;
1884  status = rocrand_create_generator(&m_generator, this->type());
1885  if(status != ROCRAND_STATUS_SUCCESS)
1886  throw rocrand_cpp::error(status);
1887  try
1888  {
1889  this->order(order_value);
1890  this->seed(seed_value);
1891  }
1892  catch(...)
1893  {
1894  (void)rocrand_destroy_generator(m_generator);
1895  throw;
1896  }
1897  }
1898 
1900  explicit lfsr113_engine(rocrand_generator& generator) : m_generator(generator)
1901  {
1902  if(generator == NULL)
1903  {
1904  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
1905  }
1906  generator = NULL;
1907  }
1908 
1909  lfsr113_engine(const lfsr113_engine&) = delete;
1910 
1911  lfsr113_engine& operator=(const lfsr113_engine&) = delete;
1912 
1914  lfsr113_engine(lfsr113_engine&& rhs) noexcept : m_generator(rhs.m_generator)
1915  {
1916  rhs.m_generator = nullptr;
1917  }
1918 
1920  lfsr113_engine& operator=(lfsr113_engine&& rhs) noexcept
1921  {
1922  rocrand_status status = rocrand_destroy_generator(m_generator);
1923  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
1924  (void)status;
1925 
1926  m_generator = rhs.m_generator;
1927  rhs.m_generator = nullptr;
1928  return *this;
1929  }
1930 
1932  ~lfsr113_engine() noexcept(false)
1933  {
1934  rocrand_status status = rocrand_destroy_generator(m_generator);
1935  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
1936  throw rocrand_cpp::error(status);
1937  }
1938 
1940  void stream(hipStream_t value)
1941  {
1942  rocrand_status status = rocrand_set_stream(m_generator, value);
1943  if(status != ROCRAND_STATUS_SUCCESS)
1944  throw rocrand_cpp::error(status);
1945  }
1946 
1948  void order(order_type value)
1949  {
1950  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
1951  if(status != ROCRAND_STATUS_SUCCESS)
1952  throw rocrand_cpp::error(status);
1953  }
1954 
1956  void seed(unsigned long long value)
1957  {
1958  rocrand_status status = rocrand_set_seed(this->m_generator, value);
1959  if(status != ROCRAND_STATUS_SUCCESS)
1960  throw rocrand_cpp::error(status);
1961  }
1962 
1964  void seed(seed_type value)
1965  {
1966  rocrand_status status = rocrand_set_seed_uint4(this->m_generator, value);
1967  if(status != ROCRAND_STATUS_SUCCESS)
1968  throw rocrand_cpp::error(status);
1969  }
1970 
1972  template<class Generator>
1973  void operator()(result_type* output, size_t size)
1974  {
1975  rocrand_status status;
1976  status = rocrand_generate(m_generator, output, size);
1977  if(status != ROCRAND_STATUS_SUCCESS)
1978  throw rocrand_cpp::error(status);
1979  }
1980 
1982  static constexpr result_type min()
1983  {
1984  return 0;
1985  }
1986 
1988  static constexpr result_type max()
1989  {
1990  return std::numeric_limits<unsigned int>::max();
1991  }
1992 
1994  static constexpr rocrand_rng_type type()
1995  {
1996  return ROCRAND_RNG_PSEUDO_LFSR113;
1997  }
1998 
1999 private:
2000  rocrand_generator m_generator;
2001 
2003  template<class T>
2004  friend class ::rocrand_cpp::uniform_int_distribution;
2005 
2006  template<class T>
2007  friend class ::rocrand_cpp::uniform_real_distribution;
2008 
2009  template<class T>
2010  friend class ::rocrand_cpp::normal_distribution;
2011 
2012  template<class T>
2013  friend class ::rocrand_cpp::lognormal_distribution;
2014 
2015  template<class T>
2016  friend class ::rocrand_cpp::poisson_distribution;
2018 };
2019 
2021 template<unsigned int DefaultSeedX,
2022  unsigned int DefaultSeedY,
2023  unsigned int DefaultSeedZ,
2024  unsigned int DefaultSeedW>
2025 constexpr typename lfsr113_engine<DefaultSeedX, DefaultSeedY, DefaultSeedZ, DefaultSeedW>::seed_type
2026  lfsr113_engine<DefaultSeedX, DefaultSeedY, DefaultSeedZ, DefaultSeedW>::default_seed;
2028 
2035 template<unsigned long long DefaultSeed = 0ULL>
2036 class mt19937_engine
2037 {
2038 public:
2040  typedef unsigned int result_type;
2042  typedef rocrand_ordering order_type;
2044  typedef unsigned long long seed_type;
2046  static constexpr seed_type default_seed = DefaultSeed;
2047 
2056  mt19937_engine(seed_type seed_value = DefaultSeed,
2057  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
2058  {
2059  rocrand_status status;
2060  status = rocrand_create_generator(&m_generator, this->type());
2061  if(status != ROCRAND_STATUS_SUCCESS)
2062  throw rocrand_cpp::error(status);
2063  try
2064  {
2065  this->order(order_value);
2066  this->seed(seed_value);
2067  }
2068  catch(...)
2069  {
2070  (void)rocrand_destroy_generator(m_generator);
2071  throw;
2072  }
2073  }
2074 
2076  explicit mt19937_engine(rocrand_generator& generator) : m_generator(generator)
2077  {
2078  if(generator == NULL)
2079  {
2080  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
2081  }
2082  generator = NULL;
2083  }
2084 
2085  mt19937_engine(const mt19937_engine&) = delete;
2086 
2087  mt19937_engine& operator=(const mt19937_engine&) = delete;
2088 
2090  mt19937_engine(mt19937_engine&& rhs) noexcept : m_generator(rhs.m_generator)
2091  {
2092  rhs.m_generator = nullptr;
2093  }
2094 
2096  mt19937_engine& operator=(mt19937_engine&& rhs) noexcept
2097  {
2098  rocrand_status status = rocrand_destroy_generator(m_generator);
2099  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
2100  (void)status;
2101 
2102  m_generator = rhs.m_generator;
2103  rhs.m_generator = nullptr;
2104  return *this;
2105  }
2106 
2108  ~mt19937_engine() noexcept(false)
2109  {
2110  rocrand_status status = rocrand_destroy_generator(m_generator);
2111  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
2112  throw rocrand_cpp::error(status);
2113  }
2114 
2116  void stream(hipStream_t value)
2117  {
2118  rocrand_status status = rocrand_set_stream(m_generator, value);
2119  if(status != ROCRAND_STATUS_SUCCESS)
2120  throw rocrand_cpp::error(status);
2121  }
2122 
2124  void order(order_type value)
2125  {
2126  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
2127  if(status != ROCRAND_STATUS_SUCCESS)
2128  throw rocrand_cpp::error(status);
2129  }
2130 
2132  void seed(seed_type value)
2133  {
2134  rocrand_status status = rocrand_set_seed(this->m_generator, value);
2135  if(status != ROCRAND_STATUS_SUCCESS)
2136  throw rocrand_cpp::error(status);
2137  }
2138 
2140  template<class Generator>
2141  void operator()(result_type* output, size_t size)
2142  {
2143  rocrand_status status;
2144  status = rocrand_generate(m_generator, output, size);
2145  if(status != ROCRAND_STATUS_SUCCESS)
2146  throw rocrand_cpp::error(status);
2147  }
2148 
2150  static constexpr result_type min()
2151  {
2152  return 0;
2153  }
2154 
2156  static constexpr result_type max()
2157  {
2158  return std::numeric_limits<unsigned int>::max();
2159  }
2160 
2162  static constexpr rocrand_rng_type type()
2163  {
2164  return ROCRAND_RNG_PSEUDO_MT19937;
2165  }
2166 
2167 private:
2168  rocrand_generator m_generator;
2169 
2171  template<class T>
2172  friend class ::rocrand_cpp::uniform_int_distribution;
2173 
2174  template<class T>
2175  friend class ::rocrand_cpp::uniform_real_distribution;
2176 
2177  template<class T>
2178  friend class ::rocrand_cpp::normal_distribution;
2179 
2180  template<class T>
2181  friend class ::rocrand_cpp::lognormal_distribution;
2182 
2183  template<class T>
2184  friend class ::rocrand_cpp::poisson_distribution;
2186 };
2187 
2189 template<unsigned long long DefaultSeed>
2190 constexpr typename mt19937_engine<DefaultSeed>::seed_type mt19937_engine<DefaultSeed>::default_seed;
2192 
2198 template<unsigned int DefaultNumDimensions = 1>
2199 class sobol32_engine
2200 {
2201 public:
2203  typedef unsigned int result_type;
2205  typedef rocrand_ordering order_type;
2207  typedef unsigned long long offset_type;
2212  typedef unsigned int dimensions_num_type;
2214  static constexpr dimensions_num_type default_num_dimensions = DefaultNumDimensions;
2215 
2223  sobol32_engine(dimensions_num_type num_of_dimensions = DefaultNumDimensions,
2224  offset_type offset_value = 0,
2225  order_type order_value = ROCRAND_ORDERING_QUASI_DEFAULT)
2226  {
2227  rocrand_status status;
2228  status = rocrand_create_generator(&m_generator, this->type());
2229  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
2230  try
2231  {
2232  this->order(order_value);
2233  if(offset_value > 0)
2234  {
2235  this->offset(offset_value);
2236  }
2237  this->dimensions(num_of_dimensions);
2238  }
2239  catch(...)
2240  {
2241  (void)rocrand_destroy_generator(m_generator);
2242  throw;
2243  }
2244  }
2245 
2247  explicit sobol32_engine(rocrand_generator& generator)
2248  : m_generator(generator)
2249  {
2250  if(generator == NULL)
2251  {
2252  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
2253  }
2254  generator = NULL;
2255  }
2256 
2257  sobol32_engine(const sobol32_engine&) = delete;
2258 
2259  sobol32_engine& operator=(const sobol32_engine&) = delete;
2260 
2262  sobol32_engine(sobol32_engine&& rhs) noexcept : m_generator(rhs.m_generator)
2263  {
2264  rhs.m_generator = nullptr;
2265  }
2266 
2268  sobol32_engine& operator=(sobol32_engine&& rhs) noexcept
2269  {
2270  rocrand_status status = rocrand_destroy_generator(m_generator);
2271  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
2272  (void)status;
2273 
2274  m_generator = rhs.m_generator;
2275  rhs.m_generator = nullptr;
2276  return *this;
2277  }
2278 
2280  ~sobol32_engine() noexcept(false)
2281  {
2282  rocrand_status status = rocrand_destroy_generator(m_generator);
2283  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
2284  throw rocrand_cpp::error(status);
2285  }
2286 
2288  void stream(hipStream_t value)
2289  {
2290  rocrand_status status = rocrand_set_stream(m_generator, value);
2291  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
2292  }
2293 
2295  void order(order_type value)
2296  {
2297  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
2298  if(status != ROCRAND_STATUS_SUCCESS)
2299  throw rocrand_cpp::error(status);
2300  }
2301 
2303  void offset(offset_type value)
2304  {
2305  rocrand_status status = rocrand_set_offset(this->m_generator, value);
2306  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
2307  }
2308 
2319  void dimensions(dimensions_num_type value)
2320  {
2321  rocrand_status status =
2322  rocrand_set_quasi_random_generator_dimensions(this->m_generator, value);
2323  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
2324  }
2325 
2341  template<class Generator>
2342  void operator()(result_type * output, size_t size)
2343  {
2344  rocrand_status status;
2345  status = rocrand_generate(m_generator, output, size);
2346  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
2347  }
2348 
2350  static constexpr result_type min()
2351  {
2352  return 0;
2353  }
2354 
2356  static constexpr result_type max()
2357  {
2358  return std::numeric_limits<unsigned int>::max();
2359  }
2360 
2362  static constexpr rocrand_rng_type type()
2363  {
2364  return ROCRAND_RNG_QUASI_SOBOL32;
2365  }
2366 
2367 private:
2368  rocrand_generator m_generator;
2369 
2371  template<class T>
2372  friend class ::rocrand_cpp::uniform_int_distribution;
2373 
2374  template<class T>
2375  friend class ::rocrand_cpp::uniform_real_distribution;
2376 
2377  template<class T>
2378  friend class ::rocrand_cpp::normal_distribution;
2379 
2380  template<class T>
2381  friend class ::rocrand_cpp::lognormal_distribution;
2382 
2383  template<class T>
2384  friend class ::rocrand_cpp::poisson_distribution;
2386 };
2387 
2389 template<unsigned int DefaultNumDimensions>
2390 constexpr typename sobol32_engine<DefaultNumDimensions>::dimensions_num_type
2391  sobol32_engine<DefaultNumDimensions>::default_num_dimensions;
2393 
2399 template<unsigned int DefaultNumDimensions = 1>
2400 class scrambled_sobol32_engine
2401 {
2402 public:
2404  typedef unsigned int result_type;
2406  typedef unsigned long long offset_type;
2408  typedef rocrand_ordering order_type;
2413  typedef unsigned int dimensions_num_type;
2415  static constexpr dimensions_num_type default_num_dimensions = DefaultNumDimensions;
2416 
2424  scrambled_sobol32_engine(dimensions_num_type num_of_dimensions = DefaultNumDimensions,
2425  offset_type offset_value = 0,
2426  order_type order_value = ROCRAND_ORDERING_QUASI_DEFAULT)
2427  {
2428  rocrand_status status;
2429  status = rocrand_create_generator(&m_generator, this->type());
2430  if(status != ROCRAND_STATUS_SUCCESS)
2431  throw rocrand_cpp::error(status);
2432  try
2433  {
2434  this->order(order_value);
2435  if(offset_value > 0)
2436  {
2437  this->offset(offset_value);
2438  }
2439  this->dimensions(num_of_dimensions);
2440  }
2441  catch(...)
2442  {
2443  (void)rocrand_destroy_generator(m_generator);
2444  throw;
2445  }
2446  }
2447 
2449  explicit scrambled_sobol32_engine(rocrand_generator& generator) : m_generator(generator)
2450  {
2451  if(generator == NULL)
2452  {
2453  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
2454  }
2455  generator = NULL;
2456  }
2457 
2458  scrambled_sobol32_engine(const scrambled_sobol32_engine&) = delete;
2459 
2460  scrambled_sobol32_engine& operator=(const scrambled_sobol32_engine&) = delete;
2461 
2463  scrambled_sobol32_engine(scrambled_sobol32_engine&& rhs) noexcept : m_generator(rhs.m_generator)
2464  {
2465  rhs.m_generator = nullptr;
2466  }
2467 
2469  scrambled_sobol32_engine& operator=(scrambled_sobol32_engine&& rhs) noexcept
2470  {
2471  rocrand_status status = rocrand_destroy_generator(m_generator);
2472  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
2473  (void)status;
2474 
2475  m_generator = rhs.m_generator;
2476  rhs.m_generator = nullptr;
2477  return *this;
2478  }
2479 
2481  ~scrambled_sobol32_engine() noexcept(false)
2482  {
2483  rocrand_status status = rocrand_destroy_generator(m_generator);
2484  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
2485  throw rocrand_cpp::error(status);
2486  }
2487 
2489  void stream(hipStream_t value)
2490  {
2491  rocrand_status status = rocrand_set_stream(m_generator, value);
2492  if(status != ROCRAND_STATUS_SUCCESS)
2493  throw rocrand_cpp::error(status);
2494  }
2495 
2497  void order(order_type value)
2498  {
2499  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
2500  if(status != ROCRAND_STATUS_SUCCESS)
2501  throw rocrand_cpp::error(status);
2502  }
2503 
2505  void offset(offset_type value)
2506  {
2507  rocrand_status status = rocrand_set_offset(this->m_generator, value);
2508  if(status != ROCRAND_STATUS_SUCCESS)
2509  throw rocrand_cpp::error(status);
2510  }
2511 
2522  void dimensions(dimensions_num_type value)
2523  {
2524  rocrand_status status
2525  = rocrand_set_quasi_random_generator_dimensions(this->m_generator, value);
2526  if(status != ROCRAND_STATUS_SUCCESS)
2527  throw rocrand_cpp::error(status);
2528  }
2529 
2545  template<class Generator>
2546  void operator()(result_type* output, size_t size)
2547  {
2548  rocrand_status status;
2549  status = rocrand_generate(m_generator, output, size);
2550  if(status != ROCRAND_STATUS_SUCCESS)
2551  throw rocrand_cpp::error(status);
2552  }
2553 
2555  static constexpr result_type min()
2556  {
2557  return 0;
2558  }
2559 
2561  static constexpr result_type max()
2562  {
2563  return std::numeric_limits<unsigned int>::max();
2564  }
2565 
2567  static constexpr rocrand_rng_type type()
2568  {
2569  return ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL32;
2570  }
2571 
2572 private:
2573  rocrand_generator m_generator;
2574 
2576  template<class T>
2577  friend class ::rocrand_cpp::uniform_int_distribution;
2578 
2579  template<class T>
2580  friend class ::rocrand_cpp::uniform_real_distribution;
2581 
2582  template<class T>
2583  friend class ::rocrand_cpp::normal_distribution;
2584 
2585  template<class T>
2586  friend class ::rocrand_cpp::lognormal_distribution;
2587 
2588  template<class T>
2589  friend class ::rocrand_cpp::poisson_distribution;
2591 };
2592 
2594 template<unsigned int DefaultNumDimensions>
2595 constexpr typename scrambled_sobol32_engine<DefaultNumDimensions>::dimensions_num_type
2596  scrambled_sobol32_engine<DefaultNumDimensions>::default_num_dimensions;
2598 
2604 template<unsigned int DefaultNumDimensions = 1>
2605 class sobol64_engine
2606 {
2607 public:
2609  typedef unsigned long long int result_type;
2611  typedef unsigned long long int offset_type;
2613  typedef rocrand_ordering order_type;
2618  typedef unsigned int dimensions_num_type;
2620  static constexpr dimensions_num_type default_num_dimensions = DefaultNumDimensions;
2621 
2629  sobol64_engine(dimensions_num_type num_of_dimensions = DefaultNumDimensions,
2630  offset_type offset_value = 0,
2631  order_type order_value = ROCRAND_ORDERING_QUASI_DEFAULT)
2632  {
2633  rocrand_status status;
2634  status = rocrand_create_generator(&m_generator, this->type());
2635  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
2636  try
2637  {
2638  this->order(order_value);
2639  if(offset_value > 0)
2640  {
2641  this->offset(offset_value);
2642  }
2643  this->dimensions(num_of_dimensions);
2644  }
2645  catch(...)
2646  {
2647  (void)rocrand_destroy_generator(m_generator);
2648  throw;
2649  }
2650  }
2651 
2653  explicit sobol64_engine(rocrand_generator& generator)
2654  : m_generator(generator)
2655  {
2656  if(generator == NULL)
2657  {
2658  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
2659  }
2660  generator = NULL;
2661  }
2662 
2663  sobol64_engine(const sobol64_engine&) = delete;
2664 
2665  sobol64_engine& operator=(const sobol64_engine&) = delete;
2666 
2668  sobol64_engine(sobol64_engine&& rhs) noexcept : m_generator(rhs.m_generator)
2669  {
2670  rhs.m_generator = nullptr;
2671  }
2672 
2674  sobol64_engine& operator=(sobol64_engine&& rhs) noexcept
2675  {
2676  rocrand_status status = rocrand_destroy_generator(m_generator);
2677  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
2678  (void)status;
2679 
2680  m_generator = rhs.m_generator;
2681  rhs.m_generator = nullptr;
2682  return *this;
2683  }
2684 
2686  ~sobol64_engine() noexcept(false)
2687  {
2688  rocrand_status status = rocrand_destroy_generator(m_generator);
2689  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
2690  throw rocrand_cpp::error(status);
2691  }
2692 
2694  void stream(hipStream_t value)
2695  {
2696  rocrand_status status = rocrand_set_stream(m_generator, value);
2697  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
2698  }
2699 
2701  void order(order_type value)
2702  {
2703  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
2704  if(status != ROCRAND_STATUS_SUCCESS)
2705  throw rocrand_cpp::error(status);
2706  }
2707 
2709  void offset(offset_type value)
2710  {
2711  rocrand_status status = rocrand_set_offset(this->m_generator, value);
2712  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
2713  }
2714 
2725  void dimensions(dimensions_num_type value)
2726  {
2727  rocrand_status status =
2728  rocrand_set_quasi_random_generator_dimensions(this->m_generator, value);
2729  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
2730  }
2731 
2747  template<class Generator>
2748  void operator()(result_type * output, size_t size)
2749  {
2750  rocrand_status status;
2751  status = rocrand_generate_long_long(m_generator, output, size);
2752  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
2753  }
2754 
2756  static constexpr result_type min()
2757  {
2758  return 0;
2759  }
2760 
2762  static constexpr result_type max()
2763  {
2764  return std::numeric_limits<result_type>::max();
2765  }
2766 
2768  static constexpr rocrand_rng_type type()
2769  {
2770  return ROCRAND_RNG_QUASI_SOBOL64;
2771  }
2772 
2773 private:
2774  rocrand_generator m_generator;
2775 
2777  template<class T>
2778  friend class ::rocrand_cpp::uniform_int_distribution;
2779 
2780  template<class T>
2781  friend class ::rocrand_cpp::uniform_real_distribution;
2782 
2783  template<class T>
2784  friend class ::rocrand_cpp::normal_distribution;
2785 
2786  template<class T>
2787  friend class ::rocrand_cpp::lognormal_distribution;
2788 
2789  template<class T>
2790  friend class ::rocrand_cpp::poisson_distribution;
2792 };
2793 
2795 template<unsigned int DefaultNumDimensions>
2796 constexpr typename sobol64_engine<DefaultNumDimensions>::dimensions_num_type
2797  sobol64_engine<DefaultNumDimensions>::default_num_dimensions;
2799 
2805 template<unsigned int DefaultNumDimensions = 1>
2806 class scrambled_sobol64_engine
2807 {
2808 public:
2810  typedef unsigned long long int result_type;
2812  typedef rocrand_ordering order_type;
2814  typedef unsigned long long int offset_type;
2819  typedef unsigned int dimensions_num_type;
2821  static constexpr dimensions_num_type default_num_dimensions = DefaultNumDimensions;
2822 
2830  scrambled_sobol64_engine(dimensions_num_type num_of_dimensions = DefaultNumDimensions,
2831  offset_type offset_value = 0,
2832  order_type order_value = ROCRAND_ORDERING_QUASI_DEFAULT)
2833  {
2834  rocrand_status status;
2835  status = rocrand_create_generator(&m_generator, this->type());
2836  if(status != ROCRAND_STATUS_SUCCESS)
2837  throw rocrand_cpp::error(status);
2838  try
2839  {
2840  this->order(order_value);
2841  if(offset_value > 0)
2842  {
2843  this->offset(offset_value);
2844  }
2845  this->dimensions(num_of_dimensions);
2846  }
2847  catch(...)
2848  {
2849  (void)rocrand_destroy_generator(m_generator);
2850  throw;
2851  }
2852  }
2853 
2855  explicit scrambled_sobol64_engine(rocrand_generator& generator) : m_generator(generator)
2856  {
2857  if(generator == NULL)
2858  {
2859  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
2860  }
2861  generator = NULL;
2862  }
2863 
2864  scrambled_sobol64_engine(const scrambled_sobol64_engine&) = delete;
2865 
2866  scrambled_sobol64_engine& operator=(const scrambled_sobol64_engine&) = delete;
2867 
2869  scrambled_sobol64_engine(scrambled_sobol64_engine&& rhs) noexcept : m_generator(rhs.m_generator)
2870  {
2871  rhs.m_generator = nullptr;
2872  }
2873 
2875  scrambled_sobol64_engine& operator=(scrambled_sobol64_engine&& rhs) noexcept
2876  {
2877  rocrand_status status = rocrand_destroy_generator(m_generator);
2878  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
2879  (void)status;
2880 
2881  m_generator = rhs.m_generator;
2882  rhs.m_generator = nullptr;
2883  return *this;
2884  }
2885 
2887  ~scrambled_sobol64_engine() noexcept(false)
2888  {
2889  rocrand_status status = rocrand_destroy_generator(m_generator);
2890  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
2891  throw rocrand_cpp::error(status);
2892  }
2893 
2895  void stream(hipStream_t value)
2896  {
2897  rocrand_status status = rocrand_set_stream(m_generator, value);
2898  if(status != ROCRAND_STATUS_SUCCESS)
2899  throw rocrand_cpp::error(status);
2900  }
2901 
2903  void order(order_type value)
2904  {
2905  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
2906  if(status != ROCRAND_STATUS_SUCCESS)
2907  throw rocrand_cpp::error(status);
2908  }
2909 
2911  void offset(offset_type value)
2912  {
2913  rocrand_status status = rocrand_set_offset(this->m_generator, value);
2914  if(status != ROCRAND_STATUS_SUCCESS)
2915  throw rocrand_cpp::error(status);
2916  }
2917 
2928  void dimensions(dimensions_num_type value)
2929  {
2930  rocrand_status status
2931  = rocrand_set_quasi_random_generator_dimensions(this->m_generator, value);
2932  if(status != ROCRAND_STATUS_SUCCESS)
2933  throw rocrand_cpp::error(status);
2934  }
2935 
2951  template<class Generator>
2952  void operator()(result_type* output, size_t size)
2953  {
2954  rocrand_status status;
2955  status = rocrand_generate_long_long(m_generator, output, size);
2956  if(status != ROCRAND_STATUS_SUCCESS)
2957  throw rocrand_cpp::error(status);
2958  }
2959 
2961  static constexpr result_type min()
2962  {
2963  return 0;
2964  }
2965 
2967  static constexpr result_type max()
2968  {
2969  return std::numeric_limits<result_type>::max();
2970  }
2971 
2973  static constexpr rocrand_rng_type type()
2974  {
2975  return ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL64;
2976  }
2977 
2978 private:
2979  rocrand_generator m_generator;
2980 
2982  template<class T>
2983  friend class ::rocrand_cpp::uniform_int_distribution;
2984 
2985  template<class T>
2986  friend class ::rocrand_cpp::uniform_real_distribution;
2987 
2988  template<class T>
2989  friend class ::rocrand_cpp::normal_distribution;
2990 
2991  template<class T>
2992  friend class ::rocrand_cpp::lognormal_distribution;
2993 
2994  template<class T>
2995  friend class ::rocrand_cpp::poisson_distribution;
2997 };
2998 
3000 template<unsigned int DefaultNumDimensions>
3001 constexpr typename scrambled_sobol64_engine<DefaultNumDimensions>::dimensions_num_type
3002  scrambled_sobol64_engine<DefaultNumDimensions>::default_num_dimensions;
3004 
3009 template<unsigned long long DefaultSeed = 0>
3010 class threefry2x32_20_engine
3011 {
3012 public:
3014  typedef unsigned int result_type;
3016  typedef rocrand_ordering order_type;
3018  typedef unsigned long long offset_type;
3020  typedef unsigned long long seed_type;
3022  static constexpr seed_type default_seed = DefaultSeed;
3023 
3025  threefry2x32_20_engine(seed_type seed_value = DefaultSeed,
3026  offset_type offset_value = 0,
3027  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
3028  {
3029  rocrand_status status;
3030  status = rocrand_create_generator(&m_generator, this->type());
3031  if(status != ROCRAND_STATUS_SUCCESS)
3032  throw rocrand_cpp::error(status);
3033  try
3034  {
3035  if(offset_value > 0)
3036  {
3037  this->offset(offset_value);
3038  }
3039  this->order(order_value);
3040  this->seed(seed_value);
3041  }
3042  catch(...)
3043  {
3044  (void)rocrand_destroy_generator(m_generator);
3045  throw;
3046  }
3047  }
3048 
3050  explicit threefry2x32_20_engine(rocrand_generator& generator) : m_generator(generator)
3051  {
3052  if(generator == NULL)
3053  {
3054  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
3055  }
3056  generator = NULL;
3057  }
3058 
3059  threefry2x32_20_engine(const threefry2x32_20_engine&) = delete;
3060 
3061  threefry2x32_20_engine& operator=(const threefry2x32_20_engine&) = delete;
3062 
3064  threefry2x32_20_engine(threefry2x32_20_engine&& rhs) noexcept : m_generator(rhs.m_generator)
3065  {
3066  rhs.m_generator = nullptr;
3067  }
3068 
3070  threefry2x32_20_engine& operator=(threefry2x32_20_engine&& rhs) noexcept
3071  {
3072  rocrand_status status = rocrand_destroy_generator(m_generator);
3073  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
3074  (void)status;
3075 
3076  m_generator = rhs.m_generator;
3077  rhs.m_generator = nullptr;
3078  return *this;
3079  }
3080 
3082  ~threefry2x32_20_engine() noexcept(false)
3083  {
3084  rocrand_status status = rocrand_destroy_generator(m_generator);
3085  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
3086  throw rocrand_cpp::error(status);
3087  }
3088 
3090  void stream(hipStream_t value)
3091  {
3092  rocrand_status status = rocrand_set_stream(m_generator, value);
3093  if(status != ROCRAND_STATUS_SUCCESS)
3094  throw rocrand_cpp::error(status);
3095  }
3096 
3098  void order(order_type value)
3099  {
3100  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
3101  if(status != ROCRAND_STATUS_SUCCESS)
3102  throw rocrand_cpp::error(status);
3103  }
3104 
3106  void offset(offset_type value)
3107  {
3108  rocrand_status status = rocrand_set_offset(this->m_generator, value);
3109  if(status != ROCRAND_STATUS_SUCCESS)
3110  throw rocrand_cpp::error(status);
3111  }
3112 
3114  void seed(seed_type value)
3115  {
3116  rocrand_status status = rocrand_set_seed(this->m_generator, value);
3117  if(status != ROCRAND_STATUS_SUCCESS)
3118  throw rocrand_cpp::error(status);
3119  }
3120 
3122  template<class Generator>
3123  void operator()(result_type* output, size_t size)
3124  {
3125  rocrand_status status;
3126  status = rocrand_generate(m_generator, output, size);
3127  if(status != ROCRAND_STATUS_SUCCESS)
3128  throw rocrand_cpp::error(status);
3129  }
3130 
3132  static constexpr result_type min()
3133  {
3134  return 0;
3135  }
3136 
3138  static constexpr result_type max()
3139  {
3140  return std::numeric_limits<unsigned int>::max();
3141  }
3142 
3144  static constexpr rocrand_rng_type type()
3145  {
3146  return ROCRAND_RNG_PSEUDO_THREEFRY2_32_20;
3147  }
3148 
3149 private:
3150  rocrand_generator m_generator;
3151 
3153  template<class T>
3154  friend class ::rocrand_cpp::uniform_int_distribution;
3155 
3156  template<class T>
3157  friend class ::rocrand_cpp::uniform_real_distribution;
3158 
3159  template<class T>
3160  friend class ::rocrand_cpp::normal_distribution;
3161 
3162  template<class T>
3163  friend class ::rocrand_cpp::lognormal_distribution;
3164 
3165  template<class T>
3166  friend class ::rocrand_cpp::poisson_distribution;
3168 };
3169 
3171 template<unsigned long long DefaultSeed>
3172 constexpr typename threefry2x32_20_engine<DefaultSeed>::seed_type
3173  threefry2x32_20_engine<DefaultSeed>::default_seed;
3175 
3180 template<unsigned long long DefaultSeed = 0>
3181 class threefry2x64_20_engine
3182 {
3183 public:
3185  typedef unsigned long long result_type;
3187  typedef rocrand_ordering order_type;
3189  typedef unsigned long long offset_type;
3191  typedef unsigned long long seed_type;
3193  static constexpr seed_type default_seed = DefaultSeed;
3194 
3196  threefry2x64_20_engine(seed_type seed_value = DefaultSeed,
3197  offset_type offset_value = 0,
3198  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
3199  {
3200  rocrand_status status;
3201  status = rocrand_create_generator(&m_generator, this->type());
3202  if(status != ROCRAND_STATUS_SUCCESS)
3203  throw rocrand_cpp::error(status);
3204  try
3205  {
3206  if(offset_value > 0)
3207  {
3208  this->offset(offset_value);
3209  }
3210  this->order(order_value);
3211  this->seed(seed_value);
3212  }
3213  catch(...)
3214  {
3215  (void)rocrand_destroy_generator(m_generator);
3216  throw;
3217  }
3218  }
3219 
3221  explicit threefry2x64_20_engine(rocrand_generator& generator) : m_generator(generator)
3222  {
3223  if(generator == NULL)
3224  {
3225  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
3226  }
3227  generator = NULL;
3228  }
3229 
3230  threefry2x64_20_engine(const threefry2x64_20_engine&) = delete;
3231 
3232  threefry2x64_20_engine& operator=(const threefry2x64_20_engine&) = delete;
3233 
3235  threefry2x64_20_engine(threefry2x64_20_engine&& rhs) noexcept : m_generator(rhs.m_generator)
3236  {
3237  rhs.m_generator = nullptr;
3238  }
3239 
3241  threefry2x64_20_engine& operator=(threefry2x64_20_engine&& rhs) noexcept
3242  {
3243  rocrand_status status = rocrand_destroy_generator(m_generator);
3244  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
3245  (void)status;
3246 
3247  m_generator = rhs.m_generator;
3248  rhs.m_generator = nullptr;
3249  return *this;
3250  }
3251 
3253  ~threefry2x64_20_engine() noexcept(false)
3254  {
3255  rocrand_status status = rocrand_destroy_generator(m_generator);
3256  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
3257  throw rocrand_cpp::error(status);
3258  }
3259 
3261  void stream(hipStream_t value)
3262  {
3263  rocrand_status status = rocrand_set_stream(m_generator, value);
3264  if(status != ROCRAND_STATUS_SUCCESS)
3265  throw rocrand_cpp::error(status);
3266  }
3267 
3269  void order(order_type value)
3270  {
3271  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
3272  if(status != ROCRAND_STATUS_SUCCESS)
3273  throw rocrand_cpp::error(status);
3274  }
3275 
3277  void offset(offset_type value)
3278  {
3279  rocrand_status status = rocrand_set_offset(this->m_generator, value);
3280  if(status != ROCRAND_STATUS_SUCCESS)
3281  throw rocrand_cpp::error(status);
3282  }
3283 
3285  void seed(seed_type value)
3286  {
3287  rocrand_status status = rocrand_set_seed(this->m_generator, value);
3288  if(status != ROCRAND_STATUS_SUCCESS)
3289  throw rocrand_cpp::error(status);
3290  }
3291 
3293  template<class Generator>
3294  void operator()(result_type* output, size_t size)
3295  {
3296  rocrand_status status;
3297  status = rocrand_generate_long_long(m_generator, output, size);
3298  if(status != ROCRAND_STATUS_SUCCESS)
3299  throw rocrand_cpp::error(status);
3300  }
3301 
3303  static constexpr result_type min()
3304  {
3305  return 0;
3306  }
3307 
3309  static constexpr result_type max()
3310  {
3311  return std::numeric_limits<unsigned int>::max();
3312  }
3313 
3315  static constexpr rocrand_rng_type type()
3316  {
3317  return ROCRAND_RNG_PSEUDO_THREEFRY2_64_20;
3318  }
3319 
3320 private:
3321  rocrand_generator m_generator;
3322 
3324  template<class T>
3325  friend class ::rocrand_cpp::uniform_int_distribution;
3326 
3327  template<class T>
3328  friend class ::rocrand_cpp::uniform_real_distribution;
3329 
3330  template<class T>
3331  friend class ::rocrand_cpp::normal_distribution;
3332 
3333  template<class T>
3334  friend class ::rocrand_cpp::lognormal_distribution;
3335 
3336  template<class T>
3337  friend class ::rocrand_cpp::poisson_distribution;
3339 };
3340 
3342 template<unsigned long long DefaultSeed>
3343 constexpr typename threefry2x64_20_engine<DefaultSeed>::seed_type
3344  threefry2x64_20_engine<DefaultSeed>::default_seed;
3346 
3351 template<unsigned long long DefaultSeed = 0>
3352 class threefry4x32_20_engine
3353 {
3354 public:
3356  typedef unsigned int result_type;
3358  typedef rocrand_ordering order_type;
3360  typedef unsigned long long offset_type;
3362  typedef unsigned long long seed_type;
3364  static constexpr seed_type default_seed = DefaultSeed;
3365 
3367  threefry4x32_20_engine(seed_type seed_value = DefaultSeed,
3368  offset_type offset_value = 0,
3369  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
3370  {
3371  rocrand_status status;
3372  status = rocrand_create_generator(&m_generator, this->type());
3373  if(status != ROCRAND_STATUS_SUCCESS)
3374  throw rocrand_cpp::error(status);
3375  try
3376  {
3377  if(offset_value > 0)
3378  {
3379  this->offset(offset_value);
3380  }
3381  this->order(order_value);
3382  this->seed(seed_value);
3383  }
3384  catch(...)
3385  {
3386  (void)rocrand_destroy_generator(m_generator);
3387  throw;
3388  }
3389  }
3390 
3392  explicit threefry4x32_20_engine(rocrand_generator& generator) : m_generator(generator)
3393  {
3394  if(generator == NULL)
3395  {
3396  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
3397  }
3398  generator = NULL;
3399  }
3400 
3401  threefry4x32_20_engine(const threefry4x32_20_engine&) = delete;
3402 
3403  threefry4x32_20_engine& operator=(const threefry4x32_20_engine&) = delete;
3404 
3406  threefry4x32_20_engine(threefry4x32_20_engine&& rhs) noexcept : m_generator(rhs.m_generator)
3407  {
3408  rhs.m_generator = nullptr;
3409  }
3410 
3412  threefry4x32_20_engine& operator=(threefry4x32_20_engine&& rhs) noexcept
3413  {
3414  rocrand_status status = rocrand_destroy_generator(m_generator);
3415  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
3416  (void)status;
3417 
3418  m_generator = rhs.m_generator;
3419  rhs.m_generator = nullptr;
3420  return *this;
3421  }
3422 
3424  ~threefry4x32_20_engine() noexcept(false)
3425  {
3426  rocrand_status status = rocrand_destroy_generator(m_generator);
3427  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
3428  throw rocrand_cpp::error(status);
3429  }
3430 
3432  void stream(hipStream_t value)
3433  {
3434  rocrand_status status = rocrand_set_stream(m_generator, value);
3435  if(status != ROCRAND_STATUS_SUCCESS)
3436  throw rocrand_cpp::error(status);
3437  }
3438 
3440  void order(order_type value)
3441  {
3442  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
3443  if(status != ROCRAND_STATUS_SUCCESS)
3444  throw rocrand_cpp::error(status);
3445  }
3446 
3448  void offset(offset_type value)
3449  {
3450  rocrand_status status = rocrand_set_offset(this->m_generator, value);
3451  if(status != ROCRAND_STATUS_SUCCESS)
3452  throw rocrand_cpp::error(status);
3453  }
3454 
3456  void seed(seed_type value)
3457  {
3458  rocrand_status status = rocrand_set_seed(this->m_generator, value);
3459  if(status != ROCRAND_STATUS_SUCCESS)
3460  throw rocrand_cpp::error(status);
3461  }
3462 
3464  template<class Generator>
3465  void operator()(result_type* output, size_t size)
3466  {
3467  rocrand_status status;
3468  status = rocrand_generate(m_generator, output, size);
3469  if(status != ROCRAND_STATUS_SUCCESS)
3470  throw rocrand_cpp::error(status);
3471  }
3472 
3474  static constexpr result_type min()
3475  {
3476  return 0;
3477  }
3478 
3480  static constexpr result_type max()
3481  {
3482  return std::numeric_limits<unsigned int>::max();
3483  }
3484 
3486  static constexpr rocrand_rng_type type()
3487  {
3488  return ROCRAND_RNG_PSEUDO_THREEFRY4_32_20;
3489  }
3490 
3491 private:
3492  rocrand_generator m_generator;
3493 
3495  template<class T>
3496  friend class ::rocrand_cpp::uniform_int_distribution;
3497 
3498  template<class T>
3499  friend class ::rocrand_cpp::uniform_real_distribution;
3500 
3501  template<class T>
3502  friend class ::rocrand_cpp::normal_distribution;
3503 
3504  template<class T>
3505  friend class ::rocrand_cpp::lognormal_distribution;
3506 
3507  template<class T>
3508  friend class ::rocrand_cpp::poisson_distribution;
3510 };
3511 
3513 template<unsigned long long DefaultSeed>
3514 constexpr typename threefry4x32_20_engine<DefaultSeed>::seed_type
3515  threefry4x32_20_engine<DefaultSeed>::default_seed;
3517 
3522 template<unsigned long long DefaultSeed = 0>
3523 class threefry4x64_20_engine
3524 {
3525 public:
3527  typedef unsigned long long result_type;
3529  typedef rocrand_ordering order_type;
3531  typedef unsigned long long offset_type;
3533  typedef unsigned long long seed_type;
3535  static constexpr seed_type default_seed = DefaultSeed;
3536 
3538  threefry4x64_20_engine(seed_type seed_value = DefaultSeed,
3539  offset_type offset_value = 0,
3540  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
3541  {
3542  rocrand_status status;
3543  status = rocrand_create_generator(&m_generator, this->type());
3544  if(status != ROCRAND_STATUS_SUCCESS)
3545  throw rocrand_cpp::error(status);
3546  try
3547  {
3548  if(offset_value > 0)
3549  {
3550  this->offset(offset_value);
3551  }
3552  this->order(order_value);
3553  this->seed(seed_value);
3554  }
3555  catch(...)
3556  {
3557  (void)rocrand_destroy_generator(m_generator);
3558  throw;
3559  }
3560  }
3561 
3563  explicit threefry4x64_20_engine(rocrand_generator& generator) : m_generator(generator)
3564  {
3565  if(generator == NULL)
3566  {
3567  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
3568  }
3569  generator = NULL;
3570  }
3571 
3572  threefry4x64_20_engine(const threefry4x64_20_engine&) = delete;
3573 
3574  threefry4x64_20_engine& operator=(const threefry4x64_20_engine&) = delete;
3575 
3577  threefry4x64_20_engine(threefry4x64_20_engine&& rhs) noexcept : m_generator(rhs.m_generator)
3578  {
3579  rhs.m_generator = nullptr;
3580  }
3581 
3583  threefry4x64_20_engine& operator=(threefry4x64_20_engine&& rhs) noexcept
3584  {
3585  rocrand_status status = rocrand_destroy_generator(m_generator);
3586  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);
3587  (void)status;
3588 
3589  m_generator = rhs.m_generator;
3590  rhs.m_generator = nullptr;
3591  return *this;
3592  }
3593 
3595  ~threefry4x64_20_engine() noexcept(false)
3596  {
3597  rocrand_status status = rocrand_destroy_generator(m_generator);
3598  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)
3599  throw rocrand_cpp::error(status);
3600  }
3601 
3603  void stream(hipStream_t value)
3604  {
3605  rocrand_status status = rocrand_set_stream(m_generator, value);
3606  if(status != ROCRAND_STATUS_SUCCESS)
3607  throw rocrand_cpp::error(status);
3608  }
3609 
3611  void order(order_type value)
3612  {
3613  rocrand_status status = rocrand_set_ordering(this->m_generator, value);
3614  if(status != ROCRAND_STATUS_SUCCESS)
3615  throw rocrand_cpp::error(status);
3616  }
3617 
3619  void offset(offset_type value)
3620  {
3621  rocrand_status status = rocrand_set_offset(this->m_generator, value);
3622  if(status != ROCRAND_STATUS_SUCCESS)
3623  throw rocrand_cpp::error(status);
3624  }
3625 
3627  void seed(seed_type value)
3628  {
3629  rocrand_status status = rocrand_set_seed(this->m_generator, value);
3630  if(status != ROCRAND_STATUS_SUCCESS)
3631  throw rocrand_cpp::error(status);
3632  }
3633 
3635  template<class Generator>
3636  void operator()(result_type* output, size_t size)
3637  {
3638  rocrand_status status;
3639  status = rocrand_generate_long_long(m_generator, output, size);
3640  if(status != ROCRAND_STATUS_SUCCESS)
3641  throw rocrand_cpp::error(status);
3642  }
3643 
3645  static constexpr result_type min()
3646  {
3647  return 0;
3648  }
3649 
3651  static constexpr result_type max()
3652  {
3653  return std::numeric_limits<unsigned int>::max();
3654  }
3655 
3657  static constexpr rocrand_rng_type type()
3658  {
3659  return ROCRAND_RNG_PSEUDO_THREEFRY4_64_20;
3660  }
3661 
3662 private:
3663  rocrand_generator m_generator;
3664 
3666  template<class T>
3667  friend class ::rocrand_cpp::uniform_int_distribution;
3668 
3669  template<class T>
3670  friend class ::rocrand_cpp::uniform_real_distribution;
3671 
3672  template<class T>
3673  friend class ::rocrand_cpp::normal_distribution;
3674 
3675  template<class T>
3676  friend class ::rocrand_cpp::lognormal_distribution;
3677 
3678  template<class T>
3679  friend class ::rocrand_cpp::poisson_distribution;
3681 };
3682 
3684 template<unsigned long long DefaultSeed>
3685 constexpr typename threefry4x64_20_engine<DefaultSeed>::seed_type
3686  threefry4x64_20_engine<DefaultSeed>::default_seed;
3688 
3691 typedef philox4x32_10_engine<> philox4x32_10;
3694 typedef xorwow_engine<> xorwow;
3697 typedef mrg31k3p_engine<> mrg31k3p;
3700 typedef mrg32k3a_engine<> mrg32k3a;
3703 typedef mtgp32_engine<> mtgp32;
3707 typedef lfsr113_engine<> lfsr113;
3710 typedef mt19937_engine<> mt19937;
3713 typedef threefry2x32_20_engine<> threefry2x32;
3716 typedef threefry2x64_20_engine<> threefry2x64;
3719 typedef threefry4x32_20_engine<> threefry4x32;
3722 typedef threefry4x64_20_engine<> threefry4x64;
3725 typedef sobol32_engine<> sobol32;
3728 typedef scrambled_sobol32_engine<> scrambled_sobol32;
3731 typedef sobol64_engine<> sobol64;
3734 typedef scrambled_sobol64_engine<> scrambled_sobol64;
3735 
3738 typedef xorwow default_random_engine;
3739 
3767 typedef std::random_device random_device;
3768 
3771 inline int version()
3772 {
3773  int x;
3774  rocrand_status status = rocrand_get_version(&x);
3775  if(status != ROCRAND_STATUS_SUCCESS)
3776  {
3777  throw rocrand_cpp::error(status);
3778  }
3779  return x;
3780 }
3781 
3783 
3784 } // end namespace rocrand_cpp
3785 
3786 #endif // #if __cplusplus >= 201103L
3787 #endif // ROCRAND_HPP_
rocrand_cpp::error
A run-time rocRAND error.
Definition: rocrand.hpp:50
rocrand_cpp::error::error_code
error_type error_code() const noexcept
Returns the numeric error code.
Definition: rocrand.hpp:65
rocrand_cpp::error::error_string
std::string error_string() const noexcept
Returns a string description of the error.
Definition: rocrand.hpp:71
rocrand_cpp::error::operator!=
friend bool operator!=(const error &l, const error &r)
Compares two error objects for inequality.
Definition: rocrand.hpp:129
rocrand_cpp::error::to_string
static std::string to_string(error_type error)
Definition: rocrand.hpp:88
rocrand_cpp::error::what
const char * what() const noexcept override
Returns a C-string description of the error.
Definition: rocrand.hpp:77
rocrand_cpp::error::error
error(error_type error) noexcept
Definition: rocrand.hpp:58
rocrand_cpp::error::error_type
rocrand_status error_type
rocRAND error code type
Definition: rocrand.hpp:53
rocrand_cpp::error::operator==
friend bool operator==(const error &l, const error &r)
Compares two error objects for equality.
Definition: rocrand.hpp:122
rocrand_cpp::lfsr113_engine
Random number engine based on the LFSR113 algorithm.
Definition: rocrand.hpp:1840
rocrand_cpp::lfsr113_engine::operator=
lfsr113_engine & operator=(lfsr113_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:1920
rocrand_cpp::lfsr113_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:1973
rocrand_cpp::lfsr113_engine::lfsr113_engine
lfsr113_engine(lfsr113_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:1914
rocrand_cpp::lfsr113_engine::seed_type
uint4 seed_type
Definition: rocrand.hpp:1847
rocrand_cpp::lfsr113_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:1994
rocrand_cpp::lfsr113_engine::seed
void seed(unsigned long long value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:1956
rocrand_cpp::lfsr113_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:1964
rocrand_cpp::lfsr113_engine::lfsr113_engine
lfsr113_engine(unsigned long long seed_value, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1880
rocrand_cpp::lfsr113_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:1850
rocrand_cpp::lfsr113_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:1843
rocrand_cpp::lfsr113_engine::lfsr113_engine
lfsr113_engine(seed_type seed_value={DefaultSeedX, DefaultSeedY, DefaultSeedZ, DefaultSeedW}, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1860
rocrand_cpp::lfsr113_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:1988
rocrand_cpp::lfsr113_engine::lfsr113_engine
lfsr113_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1900
rocrand_cpp::lfsr113_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:1940
rocrand_cpp::lfsr113_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:1948
rocrand_cpp::lfsr113_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:1982
rocrand_cpp::lfsr113_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:1845
rocrand_cpp::lfsr113_engine::~lfsr113_engine
~lfsr113_engine() noexcept(false)
Definition: rocrand.hpp:1932
rocrand_cpp::lognormal_distribution::param_type
The type of the distribution parameter set.
Definition: rocrand.hpp:570
rocrand_cpp::lognormal_distribution::param_type::m
RealType m() const
Returns the deviation distribution parameter.
Definition: rocrand.hpp:593
rocrand_cpp::lognormal_distribution::param_type::param_type
param_type(RealType m=0.0, RealType s=1.0)
Constructs a param_type object with the given distribution parameters.
Definition: rocrand.hpp:579
rocrand_cpp::lognormal_distribution::param_type::operator!=
bool operator!=(const param_type &other) const
Returns true if the param_type is different from other.
Definition: rocrand.hpp:613
rocrand_cpp::lognormal_distribution::param_type::s
RealType s() const
Returns the deviation distribution parameter.
Definition: rocrand.hpp:601
rocrand_cpp::lognormal_distribution::param_type::param_type
param_type(const param_type &params)=default
Copy constructor.
rocrand_cpp::lognormal_distribution::param_type::operator==
bool operator==(const param_type &other) const
Returns true if the param_type is the same as other.
Definition: rocrand.hpp:607
rocrand_cpp::lognormal_distribution::param_type::operator=
param_type & operator=(const param_type &params)=default
Copy assignment operator.
rocrand_cpp::lognormal_distribution
Produces positive random numbers according to a log-normal distribution.
Definition: rocrand.hpp:555
rocrand_cpp::lognormal_distribution::param
void param(const param_type &params)
Sets the distribution parameter object.
Definition: rocrand.hpp:665
rocrand_cpp::lognormal_distribution::result_type
RealType result_type
See description for RealType template parameter.
Definition: rocrand.hpp:561
rocrand_cpp::lognormal_distribution::operator==
bool operator==(const lognormal_distribution< RealType > &other) const
Returns true if the distribution is the same as other.
Definition: rocrand.hpp:712
rocrand_cpp::lognormal_distribution::reset
static void reset()
Resets distribution's internal state if there is any.
Definition: rocrand.hpp:638
rocrand_cpp::lognormal_distribution::min
static constexpr RealType min()
Returns the smallest possible value that can be generated.
Definition: rocrand.hpp:671
rocrand_cpp::lognormal_distribution::m
RealType m() const
Returns the mean distribution parameter.
Definition: rocrand.hpp:645
rocrand_cpp::lognormal_distribution::operator()
void operator()(Generator &g, RealType *output, size_t size)
Fills output with log-normally distributed random floating-point values.
Definition: rocrand.hpp:702
rocrand_cpp::lognormal_distribution::lognormal_distribution
lognormal_distribution(RealType m=0.0, RealType s=1.0)
Constructs a new distribution object.
Definition: rocrand.hpp:625
rocrand_cpp::lognormal_distribution::max
static RealType max()
Returns the largest possible value that can be generated.
Definition: rocrand.hpp:677
rocrand_cpp::lognormal_distribution::s
RealType s() const
Returns the standard deviation distribution parameter.
Definition: rocrand.hpp:653
rocrand_cpp::lognormal_distribution::operator!=
bool operator!=(const lognormal_distribution< RealType > &other) const
Returns true if the distribution is different from other.
Definition: rocrand.hpp:720
rocrand_cpp::lognormal_distribution::lognormal_distribution
lognormal_distribution(const param_type &params)
Constructs a new distribution object.
Definition: rocrand.hpp:632
rocrand_cpp::lognormal_distribution::param
param_type param() const
Returns the distribution parameter object.
Definition: rocrand.hpp:659
rocrand_cpp::mrg31k3p_engine
Pseudorandom number engine based MRG31k3p CMRG.
Definition: rocrand.hpp:1335
rocrand_cpp::mrg31k3p_engine::mrg31k3p_engine
mrg31k3p_engine(mrg31k3p_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:1388
rocrand_cpp::mrg31k3p_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:1447
rocrand_cpp::mrg31k3p_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:1430
rocrand_cpp::mrg31k3p_engine::operator=
mrg31k3p_engine & operator=(mrg31k3p_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:1394
rocrand_cpp::mrg31k3p_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:1340
rocrand_cpp::mrg31k3p_engine::mrg31k3p_engine
mrg31k3p_engine(seed_type seed_value=DefaultSeed, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1349
rocrand_cpp::mrg31k3p_engine::seed_type
unsigned long long seed_type
Definition: rocrand.hpp:1344
rocrand_cpp::mrg31k3p_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:1342
rocrand_cpp::mrg31k3p_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:1338
rocrand_cpp::mrg31k3p_engine::~mrg31k3p_engine
~mrg31k3p_engine() noexcept(false)
Definition: rocrand.hpp:1406
rocrand_cpp::mrg31k3p_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:1456
rocrand_cpp::mrg31k3p_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:1422
rocrand_cpp::mrg31k3p_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:1346
rocrand_cpp::mrg31k3p_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:1414
rocrand_cpp::mrg31k3p_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:1462
rocrand_cpp::mrg31k3p_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:1468
rocrand_cpp::mrg31k3p_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:1438
rocrand_cpp::mrg31k3p_engine::mrg31k3p_engine
mrg31k3p_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1374
rocrand_cpp::mrg32k3a_engine
Pseudorandom number engine based MRG32k3a CMRG.
Definition: rocrand.hpp:1507
rocrand_cpp::mrg32k3a_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:1624
rocrand_cpp::mrg32k3a_engine::mrg32k3a_engine
mrg32k3a_engine(mrg32k3a_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:1560
rocrand_cpp::mrg32k3a_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:1636
rocrand_cpp::mrg32k3a_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:1601
rocrand_cpp::mrg32k3a_engine::seed_type
unsigned long long seed_type
Definition: rocrand.hpp:1516
rocrand_cpp::mrg32k3a_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:1514
rocrand_cpp::mrg32k3a_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:1512
rocrand_cpp::mrg32k3a_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:1510
rocrand_cpp::mrg32k3a_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:1608
rocrand_cpp::mrg32k3a_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:1593
rocrand_cpp::mrg32k3a_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:1518
rocrand_cpp::mrg32k3a_engine::~mrg32k3a_engine
~mrg32k3a_engine() noexcept(false)
Definition: rocrand.hpp:1578
rocrand_cpp::mrg32k3a_engine::mrg32k3a_engine
mrg32k3a_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1545
rocrand_cpp::mrg32k3a_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:1630
rocrand_cpp::mrg32k3a_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:1586
rocrand_cpp::mrg32k3a_engine::operator=
mrg32k3a_engine & operator=(mrg32k3a_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:1566
rocrand_cpp::mrg32k3a_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:1616
rocrand_cpp::mrg32k3a_engine::mrg32k3a_engine
mrg32k3a_engine(seed_type seed_value=DefaultSeed, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1521
rocrand_cpp::mt19937_engine
Random number engine based on the Mersenne Twister algorithm.
Definition: rocrand.hpp:2037
rocrand_cpp::mt19937_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:2124
rocrand_cpp::mt19937_engine::operator=
mt19937_engine & operator=(mt19937_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:2096
rocrand_cpp::mt19937_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:2042
rocrand_cpp::mt19937_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:2132
rocrand_cpp::mt19937_engine::~mt19937_engine
~mt19937_engine() noexcept(false)
Definition: rocrand.hpp:2108
rocrand_cpp::mt19937_engine::seed_type
unsigned long long seed_type
Definition: rocrand.hpp:2044
rocrand_cpp::mt19937_engine::mt19937_engine
mt19937_engine(seed_type seed_value=DefaultSeed, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:2056
rocrand_cpp::mt19937_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:2150
rocrand_cpp::mt19937_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:2141
rocrand_cpp::mt19937_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:2116
rocrand_cpp::mt19937_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:2156
rocrand_cpp::mt19937_engine::mt19937_engine
mt19937_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:2076
rocrand_cpp::mt19937_engine::mt19937_engine
mt19937_engine(mt19937_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:2090
rocrand_cpp::mt19937_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:2162
rocrand_cpp::mt19937_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:2046
rocrand_cpp::mt19937_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:2040
rocrand_cpp::mtgp32_engine
Random number engine based on the Mersenne Twister for Graphic Processors algorithm.
Definition: rocrand.hpp:1675
rocrand_cpp::mtgp32_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:1793
rocrand_cpp::mtgp32_engine::~mtgp32_engine
~mtgp32_engine() noexcept(false)
Definition: rocrand.hpp:1748
rocrand_cpp::mtgp32_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:1787
rocrand_cpp::mtgp32_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:1771
rocrand_cpp::mtgp32_engine::operator=
mtgp32_engine & operator=(mtgp32_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:1736
rocrand_cpp::mtgp32_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:1799
rocrand_cpp::mtgp32_engine::seed_type
unsigned long long seed_type
Definition: rocrand.hpp:1684
rocrand_cpp::mtgp32_engine::mtgp32_engine
mtgp32_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1715
rocrand_cpp::mtgp32_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:1756
rocrand_cpp::mtgp32_engine::mtgp32_engine
mtgp32_engine(seed_type seed_value=DefaultSeed, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1696
rocrand_cpp::mtgp32_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:1763
rocrand_cpp::mtgp32_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:1682
rocrand_cpp::mtgp32_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:1686
rocrand_cpp::mtgp32_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:1678
rocrand_cpp::mtgp32_engine::mtgp32_engine
mtgp32_engine(mtgp32_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:1730
rocrand_cpp::mtgp32_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:1779
rocrand_cpp::mtgp32_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:1680
rocrand_cpp::normal_distribution::param_type
The type of the distribution parameter set.
Definition: rocrand.hpp:366
rocrand_cpp::normal_distribution::param_type::param_type
param_type(const param_type &params)=default
Copy constructor.
rocrand_cpp::normal_distribution::param_type::operator=
param_type & operator=(const param_type &params)=default
Copy assignment operator.
rocrand_cpp::normal_distribution::param_type::mean
RealType mean() const
Returns the deviation distribution parameter.
Definition: rocrand.hpp:389
rocrand_cpp::normal_distribution::param_type::param_type
param_type(RealType mean=0.0, RealType stddev=1.0)
Constructs a param_type object with the given distribution parameters.
Definition: rocrand.hpp:375
rocrand_cpp::normal_distribution::param_type::operator==
bool operator==(const param_type &other) const
Returns true if the param_type is the same as other.
Definition: rocrand.hpp:403
rocrand_cpp::normal_distribution::param_type::stddev
RealType stddev() const
Returns the standard deviation distribution parameter.
Definition: rocrand.hpp:397
rocrand_cpp::normal_distribution::param_type::operator!=
bool operator!=(const param_type &other) const
Returns true if the param_type is different from other.
Definition: rocrand.hpp:409
rocrand_cpp::normal_distribution
Produces random numbers according to a normal distribution.
Definition: rocrand.hpp:351
rocrand_cpp::normal_distribution::max
static constexpr RealType max()
Returns the largest possible value that can be generated.
Definition: rocrand.hpp:461
rocrand_cpp::normal_distribution::normal_distribution
normal_distribution(const param_type &params)
Constructs a new distribution object.
Definition: rocrand.hpp:428
rocrand_cpp::normal_distribution::min
static constexpr RealType min()
Returns the smallest possible value that can be generated.
Definition: rocrand.hpp:455
rocrand_cpp::normal_distribution::param
void param(const param_type &params)
Sets the distribution parameter object.
Definition: rocrand.hpp:473
rocrand_cpp::normal_distribution::reset
static void reset()
Resets distribution's internal state if there is any.
Definition: rocrand.hpp:434
rocrand_cpp::normal_distribution::param
param_type param() const
Returns the distribution parameter object.
Definition: rocrand.hpp:467
rocrand_cpp::normal_distribution::mean
RealType mean() const
Returns the mean distribution parameter.
Definition: rocrand.hpp:441
rocrand_cpp::normal_distribution::operator()
void operator()(Generator &g, RealType *output, size_t size)
Fills output with normally distributed random floating-point values.
Definition: rocrand.hpp:497
rocrand_cpp::normal_distribution::operator==
bool operator==(const normal_distribution< RealType > &other) const
Returns true if the distribution is the same as other.
Definition: rocrand.hpp:507
rocrand_cpp::normal_distribution::result_type
RealType result_type
See description for RealType template parameter.
Definition: rocrand.hpp:357
rocrand_cpp::normal_distribution::normal_distribution
normal_distribution(RealType mean=0.0, RealType stddev=1.0)
Constructs a new distribution object.
Definition: rocrand.hpp:421
rocrand_cpp::normal_distribution::stddev
RealType stddev() const
Returns the standard deviation distribution parameter.
Definition: rocrand.hpp:449
rocrand_cpp::normal_distribution::operator!=
bool operator!=(const normal_distribution< RealType > &other) const
Returns true if the distribution is different from other.
Definition: rocrand.hpp:515
rocrand_cpp::philox4x32_10_engine
Pseudorandom number engine based Philox algorithm.
Definition: rocrand.hpp:921
rocrand_cpp::philox4x32_10_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:1130
rocrand_cpp::philox4x32_10_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:945
rocrand_cpp::philox4x32_10_engine::philox4x32_10_engine
philox4x32_10_engine(philox4x32_10_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:1005
rocrand_cpp::philox4x32_10_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:1074
rocrand_cpp::philox4x32_10_engine::operator=
philox4x32_10_engine & operator=(philox4x32_10_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:1016
rocrand_cpp::philox4x32_10_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:938
rocrand_cpp::philox4x32_10_engine::philox4x32_10_engine
philox4x32_10_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:985
rocrand_cpp::philox4x32_10_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:1124
rocrand_cpp::philox4x32_10_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:1039
rocrand_cpp::philox4x32_10_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:1090
rocrand_cpp::philox4x32_10_engine::seed_type
unsigned long long seed_type
Definition: rocrand.hpp:943
rocrand_cpp::philox4x32_10_engine::~philox4x32_10_engine
~philox4x32_10_engine() noexcept(false)
Definition: rocrand.hpp:1030
rocrand_cpp::philox4x32_10_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:1110
rocrand_cpp::philox4x32_10_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:1056
rocrand_cpp::philox4x32_10_engine::philox4x32_10_engine
philox4x32_10_engine(seed_type seed_value=DefaultSeed, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:954
rocrand_cpp::philox4x32_10_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:925
rocrand_cpp::philox4x32_10_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:1118
rocrand_cpp::philox4x32_10_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:931
rocrand_cpp::poisson_distribution::param_type
The type of the distribution parameter set.
Definition: rocrand.hpp:773
rocrand_cpp::poisson_distribution::param_type::operator=
param_type & operator=(const param_type &params)=default
Copy assignment operator.
rocrand_cpp::poisson_distribution::param_type::mean
double mean() const
Returns the mean distribution parameter.
Definition: rocrand.hpp:796
rocrand_cpp::poisson_distribution::param_type::param_type
param_type(double mean=1.0)
Constructs a param_type object with the given mean.
Definition: rocrand.hpp:781
rocrand_cpp::poisson_distribution::param_type::param_type
param_type(const param_type &params)=default
Copy constructor.
rocrand_cpp::poisson_distribution::param_type::operator==
bool operator==(const param_type &other) const
Returns true if the param_type is the same as other.
Definition: rocrand.hpp:802
rocrand_cpp::poisson_distribution::param_type::operator!=
bool operator!=(const param_type &other) const
Returns true if the param_type is different from other.
Definition: rocrand.hpp:808
rocrand_cpp::poisson_distribution
Produces random non-negative integer values distributed according to Poisson distribution.
Definition: rocrand.hpp:760
rocrand_cpp::poisson_distribution::min
static constexpr IntType min()
Returns the smallest possible value that can be generated.
Definition: rocrand.hpp:846
rocrand_cpp::poisson_distribution::mean
double mean() const
Returns the mean distribution parameter.
Definition: rocrand.hpp:840
rocrand_cpp::poisson_distribution::operator==
bool operator==(const poisson_distribution< IntType > &other) const
Returns true if the distribution is the same as other.
Definition: rocrand.hpp:898
rocrand_cpp::poisson_distribution::result_type
IntType result_type
See description for IntType template parameter.
Definition: rocrand.hpp:764
rocrand_cpp::poisson_distribution::param
param_type param()
Returns the distribution parameter object.
Definition: rocrand.hpp:858
rocrand_cpp::poisson_distribution::reset
static void reset()
Resets distribution's internal state if there is any.
Definition: rocrand.hpp:832
rocrand_cpp::poisson_distribution::max
static constexpr IntType max()
Returns the largest possible value that can be generated.
Definition: rocrand.hpp:852
rocrand_cpp::poisson_distribution::operator()
void operator()(Generator &g, IntType *output, size_t size)
Fills output with random non-negative integer values distributed according to Poisson distribution.
Definition: rocrand.hpp:888
rocrand_cpp::poisson_distribution::poisson_distribution
poisson_distribution(const param_type &params)
Constructs a new distribution object.
Definition: rocrand.hpp:826
rocrand_cpp::poisson_distribution::poisson_distribution
poisson_distribution(double mean=1.0)
Constructs a new distribution object.
Definition: rocrand.hpp:819
rocrand_cpp::poisson_distribution::param
void param(const param_type &params)
Sets the distribution parameter object.
Definition: rocrand.hpp:864
rocrand_cpp::poisson_distribution::operator!=
bool operator!=(const poisson_distribution< IntType > &other) const
Returns true if the distribution is different from other.
Definition: rocrand.hpp:906
rocrand_cpp::scrambled_sobol32_engine
Sobol's scrambled quasi-random sequence generator.
Definition: rocrand.hpp:2401
rocrand_cpp::scrambled_sobol32_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:2561
rocrand_cpp::scrambled_sobol32_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:2404
rocrand_cpp::scrambled_sobol32_engine::scrambled_sobol32_engine
scrambled_sobol32_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:2449
rocrand_cpp::scrambled_sobol32_engine::dimensions_num_type
unsigned int dimensions_num_type
Definition: rocrand.hpp:2413
rocrand_cpp::scrambled_sobol32_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:2497
rocrand_cpp::scrambled_sobol32_engine::scrambled_sobol32_engine
scrambled_sobol32_engine(scrambled_sobol32_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:2463
rocrand_cpp::scrambled_sobol32_engine::scrambled_sobol32_engine
scrambled_sobol32_engine(dimensions_num_type num_of_dimensions=DefaultNumDimensions, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_QUASI_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:2424
rocrand_cpp::scrambled_sobol32_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:2406
rocrand_cpp::scrambled_sobol32_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:2489
rocrand_cpp::scrambled_sobol32_engine::~scrambled_sobol32_engine
~scrambled_sobol32_engine() noexcept(false)
Definition: rocrand.hpp:2481
rocrand_cpp::scrambled_sobol32_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:2505
rocrand_cpp::scrambled_sobol32_engine::default_num_dimensions
static constexpr dimensions_num_type default_num_dimensions
The default number of dimenstions, equal to DefaultNumDimensions.
Definition: rocrand.hpp:2415
rocrand_cpp::scrambled_sobol32_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:2408
rocrand_cpp::scrambled_sobol32_engine::operator=
scrambled_sobol32_engine & operator=(scrambled_sobol32_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:2469
rocrand_cpp::scrambled_sobol32_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:2567
rocrand_cpp::scrambled_sobol32_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:2555
rocrand_cpp::scrambled_sobol32_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:2546
rocrand_cpp::scrambled_sobol32_engine::dimensions
void dimensions(dimensions_num_type value)
Set the number of dimensions of a quasi-random number generator.
Definition: rocrand.hpp:2522
rocrand_cpp::scrambled_sobol64_engine
Sobol's scrambled quasi-random sequence generator.
Definition: rocrand.hpp:2807
rocrand_cpp::scrambled_sobol64_engine::dimensions_num_type
unsigned int dimensions_num_type
Definition: rocrand.hpp:2819
rocrand_cpp::scrambled_sobol64_engine::scrambled_sobol64_engine
scrambled_sobol64_engine(scrambled_sobol64_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:2869
rocrand_cpp::scrambled_sobol64_engine::scrambled_sobol64_engine
scrambled_sobol64_engine(dimensions_num_type num_of_dimensions=DefaultNumDimensions, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_QUASI_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:2830
rocrand_cpp::scrambled_sobol64_engine::offset_type
unsigned long long int offset_type
Definition: rocrand.hpp:2814
rocrand_cpp::scrambled_sobol64_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:2961
rocrand_cpp::scrambled_sobol64_engine::result_type
unsigned long long int result_type
Definition: rocrand.hpp:2810
rocrand_cpp::scrambled_sobol64_engine::dimensions
void dimensions(dimensions_num_type value)
Set the number of dimensions of a quasi-random number generator.
Definition: rocrand.hpp:2928
rocrand_cpp::scrambled_sobol64_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:2967
rocrand_cpp::scrambled_sobol64_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:2911
rocrand_cpp::scrambled_sobol64_engine::default_num_dimensions
static constexpr dimensions_num_type default_num_dimensions
The default number of dimenstions, equal to DefaultNumDimensions.
Definition: rocrand.hpp:2821
rocrand_cpp::scrambled_sobol64_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:2812
rocrand_cpp::scrambled_sobol64_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:2952
rocrand_cpp::scrambled_sobol64_engine::operator=
scrambled_sobol64_engine & operator=(scrambled_sobol64_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:2875
rocrand_cpp::scrambled_sobol64_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:2903
rocrand_cpp::scrambled_sobol64_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:2895
rocrand_cpp::scrambled_sobol64_engine::~scrambled_sobol64_engine
~scrambled_sobol64_engine() noexcept(false)
Definition: rocrand.hpp:2887
rocrand_cpp::scrambled_sobol64_engine::scrambled_sobol64_engine
scrambled_sobol64_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:2855
rocrand_cpp::scrambled_sobol64_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:2973
rocrand_cpp::sobol32_engine
Sobol's quasi-random sequence generator.
Definition: rocrand.hpp:2200
rocrand_cpp::sobol32_engine::sobol32_engine
sobol32_engine(sobol32_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:2262
rocrand_cpp::sobol32_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:2203
rocrand_cpp::sobol32_engine::sobol32_engine
sobol32_engine(dimensions_num_type num_of_dimensions=DefaultNumDimensions, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_QUASI_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:2223
rocrand_cpp::sobol32_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:2350
rocrand_cpp::sobol32_engine::dimensions
void dimensions(dimensions_num_type value)
Set the number of dimensions of a quasi-random number generator.
Definition: rocrand.hpp:2319
rocrand_cpp::sobol32_engine::sobol32_engine
sobol32_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:2247
rocrand_cpp::sobol32_engine::~sobol32_engine
~sobol32_engine() noexcept(false)
Definition: rocrand.hpp:2280
rocrand_cpp::sobol32_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:2295
rocrand_cpp::sobol32_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:2303
rocrand_cpp::sobol32_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:2207
rocrand_cpp::sobol32_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:2342
rocrand_cpp::sobol32_engine::operator=
sobol32_engine & operator=(sobol32_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:2268
rocrand_cpp::sobol32_engine::dimensions_num_type
unsigned int dimensions_num_type
Definition: rocrand.hpp:2212
rocrand_cpp::sobol32_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:2362
rocrand_cpp::sobol32_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:2205
rocrand_cpp::sobol32_engine::default_num_dimensions
static constexpr dimensions_num_type default_num_dimensions
The default number of dimenstions, equal to DefaultNumDimensions.
Definition: rocrand.hpp:2214
rocrand_cpp::sobol32_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:2356
rocrand_cpp::sobol32_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:2288
rocrand_cpp::sobol64_engine
Sobol's quasi-random sequence generator.
Definition: rocrand.hpp:2606
rocrand_cpp::sobol64_engine::dimensions
void dimensions(dimensions_num_type value)
Set the number of dimensions of a quasi-random number generator.
Definition: rocrand.hpp:2725
rocrand_cpp::sobol64_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:2709
rocrand_cpp::sobol64_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:2701
rocrand_cpp::sobol64_engine::result_type
unsigned long long int result_type
Definition: rocrand.hpp:2609
rocrand_cpp::sobol64_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:2768
rocrand_cpp::sobol64_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:2762
rocrand_cpp::sobol64_engine::sobol64_engine
sobol64_engine(dimensions_num_type num_of_dimensions=DefaultNumDimensions, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_QUASI_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:2629
rocrand_cpp::sobol64_engine::dimensions_num_type
unsigned int dimensions_num_type
Definition: rocrand.hpp:2618
rocrand_cpp::sobol64_engine::default_num_dimensions
static constexpr dimensions_num_type default_num_dimensions
The default number of dimenstions, equal to DefaultNumDimensions.
Definition: rocrand.hpp:2620
rocrand_cpp::sobol64_engine::operator=
sobol64_engine & operator=(sobol64_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:2674
rocrand_cpp::sobol64_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:2694
rocrand_cpp::sobol64_engine::offset_type
unsigned long long int offset_type
Definition: rocrand.hpp:2611
rocrand_cpp::sobol64_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:2756
rocrand_cpp::sobol64_engine::sobol64_engine
sobol64_engine(sobol64_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:2668
rocrand_cpp::sobol64_engine::sobol64_engine
sobol64_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:2653
rocrand_cpp::sobol64_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:2613
rocrand_cpp::sobol64_engine::~sobol64_engine
~sobol64_engine() noexcept(false)
Definition: rocrand.hpp:2686
rocrand_cpp::sobol64_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:2748
rocrand_cpp::threefry2x32_20_engine
Pseudorandom number engine based on 2 state ThreeFry.
Definition: rocrand.hpp:3011
rocrand_cpp::threefry2x32_20_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:3132
rocrand_cpp::threefry2x32_20_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:3014
rocrand_cpp::threefry2x32_20_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:3090
rocrand_cpp::threefry2x32_20_engine::threefry2x32_20_engine
threefry2x32_20_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:3050
rocrand_cpp::threefry2x32_20_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:3144
rocrand_cpp::threefry2x32_20_engine::operator=
threefry2x32_20_engine & operator=(threefry2x32_20_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:3070
rocrand_cpp::threefry2x32_20_engine::threefry2x32_20_engine
threefry2x32_20_engine(seed_type seed_value=DefaultSeed, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:3025
rocrand_cpp::threefry2x32_20_engine::~threefry2x32_20_engine
~threefry2x32_20_engine() noexcept(false)
Definition: rocrand.hpp:3082
rocrand_cpp::threefry2x32_20_engine::seed_type
unsigned long long seed_type
Definition: rocrand.hpp:3020
rocrand_cpp::threefry2x32_20_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:3123
rocrand_cpp::threefry2x32_20_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:3114
rocrand_cpp::threefry2x32_20_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:3106
rocrand_cpp::threefry2x32_20_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:3022
rocrand_cpp::threefry2x32_20_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:3138
rocrand_cpp::threefry2x32_20_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:3016
rocrand_cpp::threefry2x32_20_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:3018
rocrand_cpp::threefry2x32_20_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:3098
rocrand_cpp::threefry2x32_20_engine::threefry2x32_20_engine
threefry2x32_20_engine(threefry2x32_20_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:3064
rocrand_cpp::threefry2x64_20_engine
Pseudorandom number engine based 2 state ThreeFry.
Definition: rocrand.hpp:3182
rocrand_cpp::threefry2x64_20_engine::seed_type
unsigned long long seed_type
Definition: rocrand.hpp:3191
rocrand_cpp::threefry2x64_20_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:3193
rocrand_cpp::threefry2x64_20_engine::operator=
threefry2x64_20_engine & operator=(threefry2x64_20_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:3241
rocrand_cpp::threefry2x64_20_engine::result_type
unsigned long long result_type
Definition: rocrand.hpp:3185
rocrand_cpp::threefry2x64_20_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:3285
rocrand_cpp::threefry2x64_20_engine::~threefry2x64_20_engine
~threefry2x64_20_engine() noexcept(false)
Definition: rocrand.hpp:3253
rocrand_cpp::threefry2x64_20_engine::threefry2x64_20_engine
threefry2x64_20_engine(seed_type seed_value=DefaultSeed, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:3196
rocrand_cpp::threefry2x64_20_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:3187
rocrand_cpp::threefry2x64_20_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:3315
rocrand_cpp::threefry2x64_20_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:3277
rocrand_cpp::threefry2x64_20_engine::threefry2x64_20_engine
threefry2x64_20_engine(threefry2x64_20_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:3235
rocrand_cpp::threefry2x64_20_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:3294
rocrand_cpp::threefry2x64_20_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:3269
rocrand_cpp::threefry2x64_20_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:3189
rocrand_cpp::threefry2x64_20_engine::threefry2x64_20_engine
threefry2x64_20_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:3221
rocrand_cpp::threefry2x64_20_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:3261
rocrand_cpp::threefry2x64_20_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:3303
rocrand_cpp::threefry2x64_20_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:3309
rocrand_cpp::threefry4x32_20_engine
Pseudorandom number engine based on 2 state ThreeFry.
Definition: rocrand.hpp:3353
rocrand_cpp::threefry4x32_20_engine::operator=
threefry4x32_20_engine & operator=(threefry4x32_20_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:3412
rocrand_cpp::threefry4x32_20_engine::~threefry4x32_20_engine
~threefry4x32_20_engine() noexcept(false)
Definition: rocrand.hpp:3424
rocrand_cpp::threefry4x32_20_engine::seed_type
unsigned long long seed_type
Definition: rocrand.hpp:3362
rocrand_cpp::threefry4x32_20_engine::threefry4x32_20_engine
threefry4x32_20_engine(threefry4x32_20_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:3406
rocrand_cpp::threefry4x32_20_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:3474
rocrand_cpp::threefry4x32_20_engine::threefry4x32_20_engine
threefry4x32_20_engine(seed_type seed_value=DefaultSeed, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:3367
rocrand_cpp::threefry4x32_20_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:3432
rocrand_cpp::threefry4x32_20_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:3356
rocrand_cpp::threefry4x32_20_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:3448
rocrand_cpp::threefry4x32_20_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:3456
rocrand_cpp::threefry4x32_20_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:3358
rocrand_cpp::threefry4x32_20_engine::threefry4x32_20_engine
threefry4x32_20_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:3392
rocrand_cpp::threefry4x32_20_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:3480
rocrand_cpp::threefry4x32_20_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:3360
rocrand_cpp::threefry4x32_20_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:3465
rocrand_cpp::threefry4x32_20_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:3486
rocrand_cpp::threefry4x32_20_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:3364
rocrand_cpp::threefry4x32_20_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:3440
rocrand_cpp::threefry4x64_20_engine
Pseudorandom number engine based 2 state ThreeFry.
Definition: rocrand.hpp:3524
rocrand_cpp::threefry4x64_20_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:3645
rocrand_cpp::threefry4x64_20_engine::threefry4x64_20_engine
threefry4x64_20_engine(seed_type seed_value=DefaultSeed, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:3538
rocrand_cpp::threefry4x64_20_engine::threefry4x64_20_engine
threefry4x64_20_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:3563
rocrand_cpp::threefry4x64_20_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:3535
rocrand_cpp::threefry4x64_20_engine::seed_type
unsigned long long seed_type
Definition: rocrand.hpp:3533
rocrand_cpp::threefry4x64_20_engine::operator=
threefry4x64_20_engine & operator=(threefry4x64_20_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:3583
rocrand_cpp::threefry4x64_20_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:3619
rocrand_cpp::threefry4x64_20_engine::~threefry4x64_20_engine
~threefry4x64_20_engine() noexcept(false)
Definition: rocrand.hpp:3595
rocrand_cpp::threefry4x64_20_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:3657
rocrand_cpp::threefry4x64_20_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:3603
rocrand_cpp::threefry4x64_20_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:3611
rocrand_cpp::threefry4x64_20_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:3531
rocrand_cpp::threefry4x64_20_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:3636
rocrand_cpp::threefry4x64_20_engine::threefry4x64_20_engine
threefry4x64_20_engine(threefry4x64_20_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:3577
rocrand_cpp::threefry4x64_20_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:3651
rocrand_cpp::threefry4x64_20_engine::result_type
unsigned long long result_type
Definition: rocrand.hpp:3527
rocrand_cpp::threefry4x64_20_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:3529
rocrand_cpp::threefry4x64_20_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:3627
rocrand_cpp::uniform_int_distribution
Produces random integer values uniformly distributed on the interval [0, 2^(sizeof(IntType)*8) - 1].
Definition: rocrand.hpp:146
rocrand_cpp::uniform_int_distribution::operator!=
bool operator!=(const uniform_int_distribution< IntType > &other) const
Returns true if the distribution is different from other.
Definition: rocrand.hpp:213
rocrand_cpp::uniform_int_distribution::operator()
void operator()(Generator &g, IntType *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:198
rocrand_cpp::uniform_int_distribution::result_type
IntType result_type
See description for IntType template parameter.
Definition: rocrand.hpp:152
rocrand_cpp::uniform_int_distribution::operator==
bool operator==(const uniform_int_distribution< IntType > &other) const
Returns true if the distribution is the same as other.
Definition: rocrand.hpp:206
rocrand_cpp::uniform_int_distribution::uniform_int_distribution
uniform_int_distribution()
Default constructor.
Definition: rocrand.hpp:159
rocrand_cpp::uniform_int_distribution::max
static constexpr IntType max()
Returns the largest possible value that can be generated.
Definition: rocrand.hpp:175
rocrand_cpp::uniform_int_distribution::reset
static void reset()
Resets distribution's internal state if there is any.
Definition: rocrand.hpp:164
rocrand_cpp::uniform_int_distribution::min
static constexpr IntType min()
Returns the smallest possible value that can be generated.
Definition: rocrand.hpp:169
rocrand_cpp::uniform_real_distribution
Produces random floating-point values uniformly distributed on the interval (0, 1].
Definition: rocrand.hpp:252
rocrand_cpp::uniform_real_distribution::reset
static void reset()
Resets distribution's internal state if there is any.
Definition: rocrand.hpp:270
rocrand_cpp::uniform_real_distribution::min
static constexpr RealType min()
Returns the smallest possible value that can be generated.
Definition: rocrand.hpp:275
rocrand_cpp::uniform_real_distribution::max
static constexpr RealType max()
Returns the largest possible value that can be generated.
Definition: rocrand.hpp:281
rocrand_cpp::uniform_real_distribution::result_type
RealType result_type
See description for RealType template parameter.
Definition: rocrand.hpp:258
rocrand_cpp::uniform_real_distribution::uniform_real_distribution
uniform_real_distribution()
Default constructor.
Definition: rocrand.hpp:265
rocrand_cpp::uniform_real_distribution::operator!=
bool operator!=(const uniform_real_distribution< RealType > &other) const
Returns true if the distribution is different from other.
Definition: rocrand.hpp:319
rocrand_cpp::uniform_real_distribution::operator()
void operator()(Generator &g, RealType *output, size_t size)
Fills output with uniformly distributed random floating-point values.
Definition: rocrand.hpp:304
rocrand_cpp::uniform_real_distribution::operator==
bool operator==(const uniform_real_distribution< RealType > &other) const
Returns true if the distribution is the same as other.
Definition: rocrand.hpp:312
rocrand_cpp::xorwow_engine
Pseudorandom number engine based XORWOW algorithm.
Definition: rocrand.hpp:1168
rocrand_cpp::xorwow_engine::order
void order(order_type value)
Sets the order of a random number engine.
Definition: rocrand.hpp:1254
rocrand_cpp::xorwow_engine::stream
void stream(hipStream_t value)
Sets the random number engine's hipStream for kernel launches.
Definition: rocrand.hpp:1247
rocrand_cpp::xorwow_engine::type
static constexpr rocrand_rng_type type()
Returns type of the rocRAND pseudo-random number generator associated with the engine.
Definition: rocrand.hpp:1297
rocrand_cpp::xorwow_engine::seed
void seed(seed_type value)
Sets the seed of the pseudo-random number engine.
Definition: rocrand.hpp:1269
rocrand_cpp::xorwow_engine::min
static constexpr result_type min()
Returns the smallest possible value that can be generated by the engine.
Definition: rocrand.hpp:1285
rocrand_cpp::xorwow_engine::order_type
rocrand_ordering order_type
Definition: rocrand.hpp:1173
rocrand_cpp::xorwow_engine::max
static constexpr result_type max()
Returns the largest possible value that can be generated by the engine.
Definition: rocrand.hpp:1291
rocrand_cpp::xorwow_engine::xorwow_engine
xorwow_engine(xorwow_engine &&rhs) noexcept
Move construct from an other engine, moving the state over.
Definition: rocrand.hpp:1221
rocrand_cpp::xorwow_engine::xorwow_engine
xorwow_engine(seed_type seed_value=DefaultSeed, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1182
rocrand_cpp::xorwow_engine::xorwow_engine
xorwow_engine(rocrand_generator &generator)
Constructs the pseudo-random number engine.
Definition: rocrand.hpp:1206
rocrand_cpp::xorwow_engine::operator=
xorwow_engine & operator=(xorwow_engine &&rhs) noexcept
Move assign from an other engine, moving the state over.
Definition: rocrand.hpp:1227
rocrand_cpp::xorwow_engine::~xorwow_engine
~xorwow_engine() noexcept(false)
Definition: rocrand.hpp:1239
rocrand_cpp::xorwow_engine::operator()
void operator()(result_type *output, size_t size)
Fills output with uniformly distributed random integer values.
Definition: rocrand.hpp:1277
rocrand_cpp::xorwow_engine::offset
void offset(offset_type value)
Sets the offset of a random number engine.
Definition: rocrand.hpp:1262
rocrand_cpp::xorwow_engine::result_type
unsigned int result_type
Definition: rocrand.hpp:1171
rocrand_cpp::xorwow_engine::default_seed
static constexpr seed_type default_seed
The default seed equal to DefaultSeed.
Definition: rocrand.hpp:1179
rocrand_cpp::xorwow_engine::seed_type
unsigned long long seed_type
Definition: rocrand.hpp:1177
rocrand_cpp::xorwow_engine::offset_type
unsigned long long offset_type
Definition: rocrand.hpp:1175
ROCRAND_LFSR113_DEFAULT_SEED_Y
#define ROCRAND_LFSR113_DEFAULT_SEED_Y
Default Y seed for LFSR113 PRNG.
Definition: rocrand_lfsr113.h:36
ROCRAND_LFSR113_DEFAULT_SEED_W
#define ROCRAND_LFSR113_DEFAULT_SEED_W
Default W seed for LFSR113 PRNG.
Definition: rocrand_lfsr113.h:42
ROCRAND_LFSR113_DEFAULT_SEED_Z
#define ROCRAND_LFSR113_DEFAULT_SEED_Z
Default Z seed for LFSR113 PRNG.
Definition: rocrand_lfsr113.h:39
ROCRAND_LFSR113_DEFAULT_SEED_X
#define ROCRAND_LFSR113_DEFAULT_SEED_X
Default X seed for LFSR113 PRNG.
Definition: rocrand_lfsr113.h:33
rocrand_generate_short
rocrand_status ROCRANDAPI rocrand_generate_short(rocrand_generator generator, unsigned short *output_data, size_t n)
Generates uniformly distributed 16-bit unsigned integers.
rocrand_generate_normal
rocrand_status ROCRANDAPI rocrand_generate_normal(rocrand_generator generator, float *output_data, size_t n, float mean, float stddev)
Generates normally distributed float values.
rocrand_set_offset
rocrand_status ROCRANDAPI rocrand_set_offset(rocrand_generator generator, unsigned long long offset)
Sets the offset of a random number generator.
rocrand_generate_normal_double
rocrand_status ROCRANDAPI rocrand_generate_normal_double(rocrand_generator generator, double *output_data, size_t n, double mean, double stddev)
Generates normally distributed double values.
rocrand_ordering
rocrand_ordering
rocRAND generator ordering
Definition: rocrand.h:107
rocrand_generate_char
rocrand_status ROCRANDAPI rocrand_generate_char(rocrand_generator generator, unsigned char *output_data, size_t n)
Generates uniformly distributed 8-bit unsigned integers.
rocrand_generate_log_normal
rocrand_status ROCRANDAPI rocrand_generate_log_normal(rocrand_generator generator, float *output_data, size_t n, float mean, float stddev)
Generates log-normally distributed float values.
rocrand_status
rocrand_status
rocRAND function call status type
Definition: rocrand.h:59
rocrand_create_generator
rocrand_status ROCRANDAPI rocrand_create_generator(rocrand_generator *generator, rocrand_rng_type rng_type)
Creates a new random number generator.
rocrand_rng_type
rocrand_rng_type
rocRAND generator type
Definition: rocrand.h:78
rocrand_generate_long_long
rocrand_status ROCRANDAPI rocrand_generate_long_long(rocrand_generator generator, unsigned long long int *output_data, size_t n)
Generates uniformly distributed 64-bit unsigned integers.
rocrand_generate_uniform_half
rocrand_status ROCRANDAPI rocrand_generate_uniform_half(rocrand_generator generator, half *output_data, size_t n)
Generates uniformly distributed half-precision floating-point values.
rocrand_set_stream
rocrand_status ROCRANDAPI rocrand_set_stream(rocrand_generator generator, hipStream_t stream)
Sets the current stream for kernel launches.
rocrand_generate_normal_half
rocrand_status ROCRANDAPI rocrand_generate_normal_half(rocrand_generator generator, half *output_data, size_t n, half mean, half stddev)
Generates normally distributed half values.
rocrand_generate_uniform_double
rocrand_status ROCRANDAPI rocrand_generate_uniform_double(rocrand_generator generator, double *output_data, size_t n)
Generates uniformly distributed double-precision floating-point values.
rocrand_generate_uniform
rocrand_status ROCRANDAPI rocrand_generate_uniform(rocrand_generator generator, float *output_data, size_t n)
Generates uniformly distributed float values.
rocrand_set_ordering
rocrand_status ROCRANDAPI rocrand_set_ordering(rocrand_generator generator, rocrand_ordering order)
Sets the ordering of a random number generator.
rocrand_generate_poisson
rocrand_status ROCRANDAPI rocrand_generate_poisson(rocrand_generator generator, unsigned int *output_data, size_t n, double lambda)
Generates Poisson-distributed 32-bit unsigned integers.
rocrand_set_quasi_random_generator_dimensions
rocrand_status ROCRANDAPI rocrand_set_quasi_random_generator_dimensions(rocrand_generator generator, unsigned int dimensions)
Set the number of dimensions of a quasi-random number generator.
rocrand_get_version
rocrand_status ROCRANDAPI rocrand_get_version(int *version)
Returns the version number of the library.
rocrand_set_seed_uint4
rocrand_status ROCRANDAPI rocrand_set_seed_uint4(rocrand_generator generator, uint4 seed)
Sets the seeds of a pseudo-random number generator.
rocrand_generate
rocrand_status ROCRANDAPI rocrand_generate(rocrand_generator generator, unsigned int *output_data, size_t n)
Generates uniformly distributed 32-bit unsigned integers.
rocrand_generate_log_normal_double
rocrand_status ROCRANDAPI rocrand_generate_log_normal_double(rocrand_generator generator, double *output_data, size_t n, double mean, double stddev)
Generates log-normally distributed double values.
rocrand_set_seed
rocrand_status ROCRANDAPI rocrand_set_seed(rocrand_generator generator, unsigned long long seed)
Sets the seed of a pseudo-random number generator.
rocrand_generate_log_normal_half
rocrand_status ROCRANDAPI rocrand_generate_log_normal_half(rocrand_generator generator, half *output_data, size_t n, half mean, half stddev)
Generates log-normally distributed half values.
rocrand_destroy_generator
rocrand_status ROCRANDAPI rocrand_destroy_generator(rocrand_generator generator)
Destroys random number generator.
ROCRAND_ORDERING_PSEUDO_DEFAULT
@ ROCRAND_ORDERING_PSEUDO_DEFAULT
Default ordering for pseudorandom results.
Definition: rocrand.h:109
ROCRAND_ORDERING_QUASI_DEFAULT
@ ROCRAND_ORDERING_QUASI_DEFAULT
n-dimensional ordering for quasirandom results
Definition: rocrand.h:114
ROCRAND_STATUS_NOT_CREATED
@ ROCRAND_STATUS_NOT_CREATED
Generator was not created using rocrand_create_generator.
Definition: rocrand.h:62
ROCRAND_STATUS_LAUNCH_FAILURE
@ ROCRAND_STATUS_LAUNCH_FAILURE
Kernel launch failure.
Definition: rocrand.h:70
ROCRAND_STATUS_VERSION_MISMATCH
@ ROCRAND_STATUS_VERSION_MISMATCH
Header file and linked library version do not match.
Definition: rocrand.h:61
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE
@ ROCRAND_STATUS_LENGTH_NOT_MULTIPLE
Definition: rocrand.h:66
ROCRAND_STATUS_DOUBLE_PRECISION_REQUIRED
@ ROCRAND_STATUS_DOUBLE_PRECISION_REQUIRED
GPU does not have double precision.
Definition: rocrand.h:69
ROCRAND_STATUS_SUCCESS
@ ROCRAND_STATUS_SUCCESS
No errors.
Definition: rocrand.h:60
ROCRAND_STATUS_INTERNAL_ERROR
@ ROCRAND_STATUS_INTERNAL_ERROR
Internal library error.
Definition: rocrand.h:71
ROCRAND_STATUS_OUT_OF_RANGE
@ ROCRAND_STATUS_OUT_OF_RANGE
Argument out of range.
Definition: rocrand.h:65
ROCRAND_STATUS_ALLOCATION_FAILED
@ ROCRAND_STATUS_ALLOCATION_FAILED
Memory allocation failed during execution.
Definition: rocrand.h:63
ROCRAND_STATUS_TYPE_ERROR
@ ROCRAND_STATUS_TYPE_ERROR
Generator type is wrong.
Definition: rocrand.h:64
ROCRAND_RNG_QUASI_SOBOL64
@ ROCRAND_RNG_QUASI_SOBOL64
Sobol64 quasirandom generator.
Definition: rocrand.h:98
ROCRAND_RNG_PSEUDO_LFSR113
@ ROCRAND_RNG_PSEUDO_LFSR113
LFSR113 pseudorandom generator.
Definition: rocrand.h:85
ROCRAND_RNG_PSEUDO_THREEFRY2_64_20
@ ROCRAND_RNG_PSEUDO_THREEFRY2_64_20
ThreeFry 64 bit state size 2 pseudorandom generator.
Definition: rocrand.h:89
ROCRAND_RNG_PSEUDO_XORWOW
@ ROCRAND_RNG_PSEUDO_XORWOW
XORWOW pseudorandom generator.
Definition: rocrand.h:80
ROCRAND_RNG_PSEUDO_THREEFRY4_32_20
@ ROCRAND_RNG_PSEUDO_THREEFRY4_32_20
ThreeFry 32 bit state size 4 pseudorandom generator.
Definition: rocrand.h:91
ROCRAND_RNG_PSEUDO_MRG31K3P
@ ROCRAND_RNG_PSEUDO_MRG31K3P
MRG31k3p pseudorandom generator.
Definition: rocrand.h:84
ROCRAND_RNG_PSEUDO_MT19937
@ ROCRAND_RNG_PSEUDO_MT19937
Mersenne Twister MT19937 pseudorandom generator.
Definition: rocrand.h:86
ROCRAND_RNG_PSEUDO_PHILOX4_32_10
@ ROCRAND_RNG_PSEUDO_PHILOX4_32_10
PHILOX-4x32-10 pseudorandom generator.
Definition: rocrand.h:83
ROCRAND_RNG_PSEUDO_THREEFRY2_32_20
@ ROCRAND_RNG_PSEUDO_THREEFRY2_32_20
ThreeFry 32 bit state size 2 pseudorandom generator.
Definition: rocrand.h:87
ROCRAND_RNG_PSEUDO_THREEFRY4_64_20
@ ROCRAND_RNG_PSEUDO_THREEFRY4_64_20
ThreeFry 64 bit state size 4 pseudorandom generator.
Definition: rocrand.h:93
ROCRAND_RNG_PSEUDO_MTGP32
@ ROCRAND_RNG_PSEUDO_MTGP32
Mersenne Twister MTGP32 pseudorandom generator.
Definition: rocrand.h:82
ROCRAND_RNG_QUASI_SOBOL32
@ ROCRAND_RNG_QUASI_SOBOL32
Sobol32 quasirandom generator.
Definition: rocrand.h:96
ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL32
@ ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL32
Scrambled Sobol32 quasirandom generator.
Definition: rocrand.h:97
ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL64
@ ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL64
Scrambled Sobol64 quasirandom generator.
Definition: rocrand.h:99
ROCRAND_RNG_PSEUDO_MRG32K3A
@ ROCRAND_RNG_PSEUDO_MRG32K3A
MRG32k3a pseudorandom generator.
Definition: rocrand.h:81
rocrand_cpp::threefry2x32
threefry2x32_20_engine threefry2x32
Typedef of rocrand_cpp::threefry2x32_20_engine PRNG engine with default seed (0).
Definition: rocrand.hpp:3713
rocrand_cpp::mrg31k3p
mrg31k3p_engine mrg31k3p
Typedef of rocrand_cpp::mrg31k3p_engine PRNG engine with default seed (ROCRAND_MRG31K3P_DEFAULT_SEED)...
Definition: rocrand.hpp:3697
rocrand_cpp::version
int version()
Returns rocRAND version.
Definition: rocrand.hpp:3771
rocrand_cpp::mrg32k3a
mrg32k3a_engine mrg32k3a
Typedef of rocrand_cpp::mrg32k3a_engine PRNG engine with default seed (ROCRAND_MRG32K3A_DEFAULT_SEED)...
Definition: rocrand.hpp:3700
rocrand_cpp::scrambled_sobol64
scrambled_sobol64_engine scrambled_sobol64
Typedef of rocrand_cpp::scrambled_sobol64_engine QRNG engine with default number of dimensions (1).
Definition: rocrand.hpp:3734
rocrand_cpp::scrambled_sobol32
scrambled_sobol32_engine scrambled_sobol32
Typedef of rocrand_cpp::scrambled_sobol32_engine QRNG engine with default number of dimensions (1).
Definition: rocrand.hpp:3728
rocrand_cpp::sobol64
sobol64_engine sobol64
Typedef of rocrand_cpp::sobol64_engine QRNG engine with default number of dimensions (1).
Definition: rocrand.hpp:3731
rocrand_cpp::mt19937
mt19937_engine mt19937
Typedef of rocrand_cpp::mt19937_engine PRNG engine with default seed (0).
Definition: rocrand.hpp:3710
rocrand_cpp::sobol32
sobol32_engine sobol32
Typedef of rocrand_cpp::sobol32_engine QRNG engine with default number of dimensions (1).
Definition: rocrand.hpp:3725
rocrand_cpp::lfsr113
lfsr113_engine lfsr113
Typedef of rocrand_cpp::lfsr113_engine PRNG engine with default seed (ROCRAND_LFSR113_DEFAULT_SEED_X,...
Definition: rocrand.hpp:3707
rocrand_cpp::threefry4x64
threefry4x64_20_engine threefry4x64
Typedef of rocrand_cpp::threefry4x64_20_engine PRNG engine with default seed (0).
Definition: rocrand.hpp:3722
rocrand_cpp::xorwow
xorwow_engine xorwow
Typedef of rocrand_cpp::xorwow_engine PRNG engine with default seed (ROCRAND_XORWOW_DEFAULT_SEED).
Definition: rocrand.hpp:3694
rocrand_cpp::threefry4x32
threefry4x32_20_engine threefry4x32
Typedef of rocrand_cpp::threefry4x32_20_engine PRNG engine with default seed (0).
Definition: rocrand.hpp:3719
rocrand_cpp::threefry2x64
threefry2x64_20_engine threefry2x64
Typedef of rocrand_cpp::threefry2x64_20_engine PRNG engine with default seed (0).
Definition: rocrand.hpp:3716
rocrand_cpp::default_random_engine
xorwow default_random_engine
Default random engine.
Definition: rocrand.hpp:3738
rocrand_cpp::philox4x32_10
philox4x32_10_engine philox4x32_10
Typedef of rocrand_cpp::philox4x32_10_engine PRNG engine with default seed (ROCRAND_PHILOX4x32_DEFAUL...
Definition: rocrand.hpp:3691
rocrand_cpp::mtgp32
mtgp32_engine mtgp32
Typedef of rocrand_cpp::mtgp32_engine PRNG engine with default seed (0).
Definition: rocrand.hpp:3703
rocrand_cpp::random_device
std::random_device random_device
A non-deterministic uniform random number generator.
Definition: rocrand.hpp:3767