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

• library
• include
• rocrand

rocrand.hpp

1 // Copyright (c) 2017-2025 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  // IWYU pragma: begin_exports

28  #include "rocrand/rocrand.h"

29  #include "rocrand/rocrand_kernel.h"

30  // IWYU pragma: end_exports

31 

32  #include <cassert>

33  #include <exception>

34  #include <limits>

35  #include <random>

36  #include <sstream>

37  #include <string>

38  #include <type_traits>

39 

40 namespace rocrand_cpp

41 {

42 

45 

51 class error : public std::exception

52 {

53 public:

55  typedef rocrand_status error_type;

56 

60  explicit error(error_type error) noexcept

61  : m_error(error),

62  m_error_string(to_string(error))

63  {

64  }

65 

67  error_type error_code() const noexcept

68  {

69  return m_error;

70  }

71 

73  std::string error_string() const noexcept

74  {

75  return m_error_string;

76  }

77 

79  const char* what() const noexcept override

80  {

81  return m_error_string.c_str();

82  }

83 

90  static std::string to_string(error_type error)

91  {

92  switch(error)

93  {

94  case ROCRAND_STATUS_SUCCESS:

95  return "Success";

96  case ROCRAND_STATUS_VERSION_MISMATCH:

97  return "Header file and linked library version do not match";

98  case ROCRAND_STATUS_NOT_CREATED:

99  return "Generator was not created using rocrand_create_generator";

100  case ROCRAND_STATUS_ALLOCATION_FAILED:

101  return "Memory allocation failed during execution";

102  case ROCRAND_STATUS_TYPE_ERROR:

103  return "Generator type is wrong";

104  case ROCRAND_STATUS_OUT_OF_RANGE:

105  return "Argument out of range";

106  case ROCRAND_STATUS_LENGTH_NOT_MULTIPLE:

107  return "Length requested is not a multiple of dimension";

108  case ROCRAND_STATUS_DOUBLE_PRECISION_REQUIRED:

109  return "GPU does not have double precision";

110  case ROCRAND_STATUS_LAUNCH_FAILURE:

111  return "Kernel launch failure";

112  case ROCRAND_STATUS_INTERNAL_ERROR:

113  return "Internal library error";

114  default: {

115  std::stringstream s;

116  s << "Unknown rocRAND error (" << error << ")";

117  return s.str();

118  }

119  }

120  }

121 

123  friend

124  bool operator==(const error& l, const error& r)

125  {

126  return l.error_code() == r.error_code();

127  }

128 

130  friend

131  bool operator!=(const error& l, const error& r)

132  {

133  return !(l == r);

134  }

135 

136 private:

137  error_type m_error;

138  std::string m_error_string;

139 };

140 

146 template<class IntType = unsigned int>

147 class uniform_int_distribution

148 {

149  static_assert(std::is_same<unsigned char, IntType>::value

150  || std::is_same<unsigned short, IntType>::value

151  || std::is_same<unsigned long long int, IntType>::value

152  || std::is_same<unsigned int, IntType>::value,

153  "Only unsigned char, unsigned short, unsigned int and unsigned long long int "

154  "types are supported in uniform_int_distribution");

155 

156 public:

158  typedef IntType result_type;

159 

161  uniform_int_distribution()

162  {

163  }

164 

166  static void reset()

167  {

168  }

169 

171  static constexpr IntType min()

172  {

173  return 0;

174  }

175 

177  static constexpr IntType max()

178  {

179  return std::numeric_limits<IntType>::max();

180  }

181 

199  template<class Generator>

200  void operator()(Generator& g, IntType * output, size_t size)

201  {

202  rocrand_status status;

203  status = this->generate(g, output, size);

204  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

205  }

206 

208  bool operator==(const uniform_int_distribution<IntType>& other) const

209  {

210  (void) other;

211  return true;

212  }

213 

215  bool operator!=(const uniform_int_distribution<IntType>& other) const

216  {

217  return !(*this == other);

218  }

219 

220 private:

221  template<class Generator>

222  static rocrand_status generate(Generator& g, unsigned char * output, size_t size)

223  {

224  return rocrand_generate_char(g.m_generator, output, size);

225  }

226 

227  template<class Generator>

228  static rocrand_status generate(Generator& g, unsigned short * output, size_t size)

229  {

230  return rocrand_generate_short(g.m_generator, output, size);

231  }

232 

233  template<class Generator>

234  static rocrand_status generate(Generator& g, unsigned int * output, size_t size)

235  {

236  return rocrand_generate(g.m_generator, output, size);

237  }

238 

239  template<class Generator>

240  static rocrand_status generate(Generator& g, unsigned long long int* output, size_t size)

241  {

242  return rocrand_generate_long_long(g.m_generator, output, size);

243  }

244 };

245 

251 

252 template<class RealType = float>

253 class uniform_real_distribution

254 {

255  static_assert(

256  std::is_same<float, RealType>::value

257  || std::is_same<double, RealType>::value

258  || std::is_same<half, RealType>::value,

259  "Only float, double, and half types are supported in uniform_real_distribution"

260  );

261 

262 public:

264  typedef RealType result_type;

265 

267  uniform_real_distribution()

268  {

269  }

270 

272  static void reset()

273  {

274  }

275 

277  static constexpr RealType min()

278  {

279  return static_cast<RealType>(ROCRAND_2POW32_INV_DOUBLE);

280  }

281 

283  static constexpr RealType max()

284  {

285  return 1.0;

286  }

287 

305  template<class Generator>

306  void operator()(Generator& g, RealType * output, size_t size)

307  {

308  rocrand_status status;

309  status = this->generate(g, output, size);

310  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

311  }

312 

314  bool operator==(const uniform_real_distribution<RealType>& other) const

315  {

316  (void) other;

317  return true;

318  }

319 

321  bool operator!=(const uniform_real_distribution<RealType>& other) const

322  {

323  return !(*this == other);

324  }

325 

326 private:

327  template<class Generator>

328  static rocrand_status generate(Generator& g, float * output, size_t size)

329  {

330  return rocrand_generate_uniform(g.m_generator, output, size);

331  }

332 

333  template<class Generator>

334  static rocrand_status generate(Generator& g, double * output, size_t size)

335  {

336  return rocrand_generate_uniform_double(g.m_generator, output, size);

337  }

338 

339  template<class Generator>

340  static rocrand_status generate(Generator& g, half * output, size_t size)

341  {

342  return rocrand_generate_uniform_half(g.m_generator, output, size);

343  }

344 };

345 

351 template<class RealType = float>

352 class normal_distribution

353 {

354  static_assert(

355  std::is_same<float, RealType>::value

356  || std::is_same<double, RealType>::value

357  || std::is_same<half, RealType>::value,

358  "Only float, double and half types are supported in normal_distribution"

359  );

360 

361 public:

363  typedef RealType result_type;

364 

367  class param_type

368  {

369  public:

371  using distribution_type = normal_distribution<RealType>;

372 

377  param_type(RealType mean = 0.0, RealType stddev = 1.0)

378  : m_mean(mean), m_stddev(stddev)

379  {

380  }

381 

383  param_type(const param_type& params) = default;

384 

386  param_type& operator=(const param_type& params) = default;

387 

391  RealType mean() const

392  {

393  return m_mean;

394  }

395 

399  RealType stddev() const

400  {

401  return m_stddev;

402  }

403 

405  bool operator==(const param_type& other) const

406  {

407  return m_mean == other.m_mean && m_stddev == other.m_stddev;

408  }

409 

411  bool operator!=(const param_type& other) const

412  {

413  return !(*this == other);

414  }

415  private:

416  RealType m_mean;

417  RealType m_stddev;

418  };

419 

423  normal_distribution(RealType mean = 0.0, RealType stddev = 1.0)

424  : m_params(mean, stddev)

425  {

426  }

427 

430  explicit normal_distribution(const param_type& params)

431  : m_params(params)

432  {

433  }

434 

436  static void reset()

437  {

438  }

439 

443  RealType mean() const

444  {

445  return m_params.mean();

446  }

447 

451  RealType stddev() const

452  {

453  return m_params.stddev();

454  }

455 

457  static constexpr RealType min()

458  {

459  return std::numeric_limits<RealType>::lowest();

460  }

461 

463  static constexpr RealType max()

464  {

465  return std::numeric_limits<RealType>::max();

466  }

467 

469  param_type param() const

470  {

471  return m_params;

472  }

473 

475  void param(const param_type& params)

476  {

477  m_params = params;

478  }

479 

498  template<class Generator>

499  void operator()(Generator& g, RealType * output, size_t size)

500  {

501  rocrand_status status;

502  status = this->generate(g, output, size);

503  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

504  }

505 

509  bool operator==(const normal_distribution<RealType>& other) const

510  {

511  return this->m_params == other.m_params;

512  }

513 

517  bool operator!=(const normal_distribution<RealType>& other) const

518  {

519  return !(*this == other);

520  }

521 

522 private:

523  template<class Generator>

524  rocrand_status generate(Generator& g, float * output, size_t size)

525  {

526  return rocrand_generate_normal(

527  g.m_generator, output, size, this->mean(), this->stddev()

528  );

529  }

530 

531  template<class Generator>

532  rocrand_status generate(Generator& g, double * output, size_t size)

533  {

534  return rocrand_generate_normal_double(

535  g.m_generator, output, size, this->mean(), this->stddev()

536  );

537  }

538 

539  template<class Generator>

540  rocrand_status generate(Generator& g, half * output, size_t size)

541  {

542  return rocrand_generate_normal_half(

543  g.m_generator, output, size, this->mean(), this->stddev()

544  );

545  }

546 

547  param_type m_params;

548 };

549 

555 template<class RealType = float>

556 class lognormal_distribution

557 {

558  static_assert(

559  std::is_same<float, RealType>::value

560  || std::is_same<double, RealType>::value

561  || std::is_same<half, RealType>::value,

562  "Only float, double and half types are supported in lognormal_distribution"

563  );

564 

565 public:

567  typedef RealType result_type;

568 

571  class param_type

572  {

573  public:

575  using distribution_type = lognormal_distribution<RealType>;

576 

581  param_type(RealType m = 0.0, RealType s = 1.0)

582  : m_mean(m), m_stddev(s)

583  {

584  }

585 

587  param_type(const param_type& params) = default;

588 

590  param_type& operator=(const param_type& params) = default;

591 

595  RealType m() const

596  {

597  return m_mean;

598  }

599 

603  RealType s() const

604  {

605  return m_stddev;

606  }

607 

609  bool operator==(const param_type& other) const

610  {

611  return m_mean == other.m_mean && m_stddev == other.m_stddev;

612  }

613 

615  bool operator!=(const param_type& other) const

616  {

617  return !(*this == other);

618  }

619  private:

620  RealType m_mean;

621  RealType m_stddev;

622  };

623 

627  lognormal_distribution(RealType m = 0.0, RealType s = 1.0)

628  : m_params(m, s)

629  {

630  }

631 

634  explicit lognormal_distribution(const param_type& params)

635  : m_params(params)

636  {

637  }

638 

640  static void reset()

641  {

642  }

643 

647  RealType m() const

648  {

649  return m_params.m();

650  }

651 

655  RealType s() const

656  {

657  return m_params.s();

658  }

659 

661  param_type param() const

662  {

663  return m_params;

664  }

665 

667  void param(const param_type& params)

668  {

669  m_params = params;

670  }

671 

673  static constexpr RealType min()

674  {

675  return 0;

676  }

677 

679  static RealType max()

680  {

681  return std::numeric_limits<RealType>::max();

682  }

683 

703  template<class Generator>

704  void operator()(Generator& g, RealType * output, size_t size)

705  {

706  rocrand_status status;

707  status = this->generate(g, output, size);

708  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

709  }

710 

714  bool operator==(const lognormal_distribution<RealType>& other) const

715  {

716  return this->m_params == other.m_params;

717  }

718 

722  bool operator!=(const lognormal_distribution<RealType>& other) const

723  {

724  return !(*this == other);

725  }

726 

727 private:

728  template<class Generator>

729  rocrand_status generate(Generator& g, float * output, size_t size)

730  {

731  return rocrand_generate_log_normal(

732  g.m_generator, output, size, this->m(), this->s()

733  );

734  }

735 

736  template<class Generator>

737  rocrand_status generate(Generator& g, double * output, size_t size)

738  {

739  return rocrand_generate_log_normal_double(

740  g.m_generator, output, size, this->m(), this->s()

741  );

742  }

743 

744  template<class Generator>

745  rocrand_status generate(Generator& g, half * output, size_t size)

746  {

747  return rocrand_generate_log_normal_half(

748  g.m_generator, output, size, this->m(), this->s()

749  );

750  }

751 

752  param_type m_params;

753 };

754 

760 template<class IntType = unsigned int>

761 class poisson_distribution

762 {

763  static_assert(

764  std::is_same<unsigned int, IntType>::value,

765  "Only unsigned int type is supported in poisson_distribution"

766  );

767 

768 public:

770  typedef IntType result_type;

771 

774  class param_type

775  {

776  public:

778  using distribution_type = poisson_distribution<IntType>;

779 

783  param_type(double mean = 1.0)

784  : m_mean(mean)

785  {

786  }

787 

789  param_type(const param_type& params) = default;

790 

792  param_type& operator=(const param_type& params) = default;

793 

798  double mean() const

799  {

800  return m_mean;

801  }

802 

804  bool operator==(const param_type& other) const

805  {

806  return m_mean == other.m_mean;

807  }

808 

810  bool operator!=(const param_type& other) const

811  {

812  return !(*this == other);

813  }

814 

815  private:

816  double m_mean;

817  };

818 

821  poisson_distribution(double mean = 1.0)

822  : m_params(mean)

823  {

824  }

825 

828  explicit poisson_distribution(const param_type& params)

829  : m_params(params)

830  {

831  }

832 

834  static void reset()

835  {

836  }

837 

842  double mean() const

843  {

844  return m_params.mean();

845  }

846 

848  static constexpr IntType min()

849  {

850  return 0;

851  }

852 

854  static constexpr IntType max()

855  {

856  return std::numeric_limits<IntType>::max();

857  }

858 

860  param_type param()

861  {

862  return m_params;

863  }

864 

866  void param(const param_type& params)

867  {

868  m_params = params;

869  }

870 

889  template<class Generator>

890  void operator()(Generator& g, IntType * output, size_t size)

891  {

892  rocrand_status status;

893  status = rocrand_generate_poisson(g.m_generator, output, size, this->mean());

894  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

895  }

896 

900  bool operator==(const poisson_distribution<IntType>& other) const

901  {

902  return this->m_params == other.m_params;

903  }

904 

908  bool operator!=(const poisson_distribution<IntType>& other) const

909  {

910  return !(*this == other);

911  }

912 

913 private:

914  param_type m_params;

915 };

916 

921 template<unsigned long long DefaultSeed = ROCRAND_PHILOX4x32_DEFAULT_SEED>

922 class philox4x32_10_engine

923 {

924 public:

927  typedef unsigned int result_type;

928  // \typedef order_type

933  typedef rocrand_ordering order_type;

940  typedef unsigned long long offset_type;

945  typedef unsigned long long seed_type;

947  static constexpr seed_type default_seed = DefaultSeed;

948 

956  philox4x32_10_engine(seed_type seed_value = DefaultSeed,

957  offset_type offset_value = 0,

958  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

959  {

960  rocrand_status status;

961  status = rocrand_create_generator(&m_generator, this->type());

962  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

963  try

964  {

965  if(offset_value > 0)

966  {

967  this->offset(offset_value);

968  }

969  this->order(order_value);

970  this->seed(seed_value);

971  }

972  catch(...)

973  {

974  (void)rocrand_destroy_generator(m_generator);

975  throw;

976  }

977  }

978 

987  explicit philox4x32_10_engine(rocrand_generator& generator)

988  : m_generator(generator)

989  {

990  if(generator == NULL)

991  {

992  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

993  }

994  generator = NULL;

995  }

996 

997  philox4x32_10_engine(const philox4x32_10_engine&) = delete;

998 

999  philox4x32_10_engine& operator=(const philox4x32_10_engine&) = delete;

1000 

1007  philox4x32_10_engine(philox4x32_10_engine&& rhs) noexcept : m_generator(rhs.m_generator)

1008  {

1009  rhs.m_generator = nullptr;

1010  }

1011 

1018  philox4x32_10_engine& operator=(philox4x32_10_engine&& rhs) noexcept

1019  {

1020  rocrand_status status = rocrand_destroy_generator(m_generator);

1021  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

1022  (void)status;

1023 

1024  m_generator = rhs.m_generator;

1025  rhs.m_generator = nullptr;

1026  return *this;

1027  }

1028 

1032  ~philox4x32_10_engine() noexcept(false)

1033  {

1034  rocrand_status status = rocrand_destroy_generator(m_generator);

1035  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

1036  throw rocrand_cpp::error(status);

1037  }

1038 

1041  void stream(hipStream_t value)

1042  {

1043  rocrand_status status = rocrand_set_stream(m_generator, value);

1044  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1045  }

1046 

1058  void order(order_type value)

1059  {

1060  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

1061  if(status != ROCRAND_STATUS_SUCCESS)

1062  throw rocrand_cpp::error(status);

1063  }

1064 

1076  void offset(offset_type value)

1077  {

1078  rocrand_status status = rocrand_set_offset(this->m_generator, value);

1079  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1080  }

1081 

1092  void seed(seed_type value)

1093  {

1094  rocrand_status status = rocrand_set_seed(this->m_generator, value);

1095  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1096  }

1097 

1111  template<class Generator>

1112  void operator()(result_type * output, size_t size)

1113  {

1114  rocrand_status status;

1115  status = rocrand_generate(m_generator, output, size);

1116  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1117  }

1118 

1120  static constexpr result_type min()

1121  {

1122  return 0;

1123  }

1124 

1126  static constexpr result_type max()

1127  {

1128  return std::numeric_limits<unsigned int>::max();

1129  }

1130 

1132  static constexpr rocrand_rng_type type()

1133  {

1134  return ROCRAND_RNG_PSEUDO_PHILOX4_32_10;

1135  }

1136 

1137 private:

1138  rocrand_generator m_generator;

1139 

1141  template<class T>

1142  friend class ::rocrand_cpp::uniform_int_distribution;

1143 

1144  template<class T>

1145  friend class ::rocrand_cpp::uniform_real_distribution;

1146 

1147  template<class T>

1148  friend class ::rocrand_cpp::normal_distribution;

1149 

1150  template<class T>

1151  friend class ::rocrand_cpp::lognormal_distribution;

1152 

1153  template<class T>

1154  friend class ::rocrand_cpp::poisson_distribution;

1156 };

1157 

1159 template<unsigned long long DefaultSeed>

1160 constexpr typename philox4x32_10_engine<DefaultSeed>::seed_type philox4x32_10_engine<DefaultSeed>::default_seed;

1162 

1168 template<unsigned long long DefaultSeed = ROCRAND_XORWOW_DEFAULT_SEED>

1169 class xorwow_engine

1170 {

1171 public:

1173  typedef unsigned int result_type;

1175  typedef rocrand_ordering order_type;

1177  typedef unsigned long long offset_type;

1179  typedef unsigned long long seed_type;

1181  static constexpr seed_type default_seed = DefaultSeed;

1182 

1184  xorwow_engine(seed_type seed_value = DefaultSeed,

1185  offset_type offset_value = 0,

1186  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

1187  {

1188  rocrand_status status;

1189  status = rocrand_create_generator(&m_generator, this->type());

1190  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1191  try

1192  {

1193  this->order(order_value);

1194  if(offset_value > 0)

1195  {

1196  this->offset(offset_value);

1197  }

1198  this->seed(seed_value);

1199  }

1200  catch(...)

1201  {

1202  (void)rocrand_destroy_generator(m_generator);

1203  throw;

1204  }

1205  }

1206 

1208  explicit xorwow_engine(rocrand_generator& generator)

1209  : m_generator(generator)

1210  {

1211  if(generator == NULL)

1212  {

1213  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

1214  }

1215  generator = NULL;

1216  }

1217 

1218  xorwow_engine(const xorwow_engine&) = delete;

1219 

1220  xorwow_engine& operator=(const xorwow_engine&) = delete;

1221 

1223  xorwow_engine(xorwow_engine&& rhs) noexcept : m_generator(rhs.m_generator)

1224  {

1225  rhs.m_generator = nullptr;

1226  }

1227 

1229  xorwow_engine& operator=(xorwow_engine&& rhs) noexcept

1230  {

1231  rocrand_status status = rocrand_destroy_generator(m_generator);

1232  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

1233  (void)status;

1234 

1235  m_generator = rhs.m_generator;

1236  rhs.m_generator = nullptr;

1237  return *this;

1238  }

1239 

1241  ~xorwow_engine() noexcept(false)

1242  {

1243  rocrand_status status = rocrand_destroy_generator(m_generator);

1244  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

1245  throw rocrand_cpp::error(status);

1246  }

1247 

1249  void stream(hipStream_t value)

1250  {

1251  rocrand_status status = rocrand_set_stream(m_generator, value);

1252  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1253  }

1254 

1256  void order(order_type value)

1257  {

1258  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

1259  if(status != ROCRAND_STATUS_SUCCESS)

1260  throw rocrand_cpp::error(status);

1261  }

1262 

1264  void offset(offset_type value)

1265  {

1266  rocrand_status status = rocrand_set_offset(this->m_generator, value);

1267  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1268  }

1269 

1271  void seed(seed_type value)

1272  {

1273  rocrand_status status = rocrand_set_seed(this->m_generator, value);

1274  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1275  }

1276 

1278  template<class Generator>

1279  void operator()(result_type * output, size_t size)

1280  {

1281  rocrand_status status;

1282  status = rocrand_generate(m_generator, output, size);

1283  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1284  }

1285 

1287  static constexpr result_type min()

1288  {

1289  return 0;

1290  }

1291 

1293  static constexpr result_type max()

1294  {

1295  return std::numeric_limits<unsigned int>::max();

1296  }

1297 

1299  static constexpr rocrand_rng_type type()

1300  {

1301  return ROCRAND_RNG_PSEUDO_XORWOW;

1302  }

1303 

1304 private:

1305  rocrand_generator m_generator;

1306 

1308  template<class T>

1309  friend class ::rocrand_cpp::uniform_int_distribution;

1310 

1311  template<class T>

1312  friend class ::rocrand_cpp::uniform_real_distribution;

1313 

1314  template<class T>

1315  friend class ::rocrand_cpp::normal_distribution;

1316 

1317  template<class T>

1318  friend class ::rocrand_cpp::lognormal_distribution;

1319 

1320  template<class T>

1321  friend class ::rocrand_cpp::poisson_distribution;

1323 };

1324 

1326 template<unsigned long long DefaultSeed>

1327 constexpr typename xorwow_engine<DefaultSeed>::seed_type xorwow_engine<DefaultSeed>::default_seed;

1329 

1335 template<unsigned long long DefaultSeed = ROCRAND_MRG31K3P_DEFAULT_SEED>

1336 class mrg31k3p_engine

1337 {

1338 public:

1340  typedef unsigned int result_type;

1342  typedef rocrand_ordering order_type;

1344  typedef unsigned long long offset_type;

1346  typedef unsigned long long seed_type;

1348  static constexpr seed_type default_seed = DefaultSeed;

1349 

1351  mrg31k3p_engine(seed_type seed_value = DefaultSeed,

1352  offset_type offset_value = 0,

1353  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

1354  {

1355  rocrand_status status;

1356  status = rocrand_create_generator(&m_generator, this->type());

1357  if(status != ROCRAND_STATUS_SUCCESS)

1358  throw rocrand_cpp::error(status);

1359  try

1360  {

1361  this->order(order_value);

1362  if(offset_value > 0)

1363  {

1364  this->offset(offset_value);

1365  }

1366  this->seed(seed_value);

1367  }

1368  catch(...)

1369  {

1370  (void)rocrand_destroy_generator(m_generator);

1371  throw;

1372  }

1373  }

1374 

1376  explicit mrg31k3p_engine(rocrand_generator& generator) : m_generator(generator)

1377  {

1378  if(generator == NULL)

1379  {

1380  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

1381  }

1382  generator = NULL;

1383  }

1384 

1385  mrg31k3p_engine(const mrg31k3p_engine&) = delete;

1386 

1387  mrg31k3p_engine& operator=(const mrg31k3p_engine&) = delete;

1388 

1390  mrg31k3p_engine(mrg31k3p_engine&& rhs) noexcept : m_generator(rhs.m_generator)

1391  {

1392  rhs.m_generator = nullptr;

1393  }

1394 

1396  mrg31k3p_engine& operator=(mrg31k3p_engine&& rhs) noexcept

1397  {

1398  rocrand_status status = rocrand_destroy_generator(m_generator);

1399  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

1400  (void)status;

1401 

1402  m_generator = rhs.m_generator;

1403  rhs.m_generator = nullptr;

1404  return *this;

1405  }

1406 

1408  ~mrg31k3p_engine() noexcept(false)

1409  {

1410  rocrand_status status = rocrand_destroy_generator(m_generator);

1411  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

1412  throw rocrand_cpp::error(status);

1413  }

1414 

1416  void stream(hipStream_t value)

1417  {

1418  rocrand_status status = rocrand_set_stream(m_generator, value);

1419  if(status != ROCRAND_STATUS_SUCCESS)

1420  throw rocrand_cpp::error(status);

1421  }

1422 

1424  void order(order_type value)

1425  {

1426  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

1427  if(status != ROCRAND_STATUS_SUCCESS)

1428  throw rocrand_cpp::error(status);

1429  }

1430 

1432  void offset(offset_type value)

1433  {

1434  rocrand_status status = rocrand_set_offset(this->m_generator, value);

1435  if(status != ROCRAND_STATUS_SUCCESS)

1436  throw rocrand_cpp::error(status);

1437  }

1438 

1440  void seed(seed_type value)

1441  {

1442  rocrand_status status = rocrand_set_seed(this->m_generator, value);

1443  if(status != ROCRAND_STATUS_SUCCESS)

1444  throw rocrand_cpp::error(status);

1445  }

1446 

1448  template<class Generator>

1449  void operator()(result_type* output, size_t size)

1450  {

1451  rocrand_status status;

1452  status = rocrand_generate(m_generator, output, size);

1453  if(status != ROCRAND_STATUS_SUCCESS)

1454  throw rocrand_cpp::error(status);

1455  }

1456 

1458  static constexpr result_type min()

1459  {

1460  return 1;

1461  }

1462 

1464  static constexpr result_type max()

1465  {

1466  return std::numeric_limits<unsigned int>::max();

1467  }

1468 

1470  static constexpr rocrand_rng_type type()

1471  {

1472  return ROCRAND_RNG_PSEUDO_MRG31K3P;

1473  }

1474 

1475 private:

1476  rocrand_generator m_generator;

1477 

1479  template<class T>

1480  friend class ::rocrand_cpp::uniform_int_distribution;

1481 

1482  template<class T>

1483  friend class ::rocrand_cpp::uniform_real_distribution;

1484 

1485  template<class T>

1486  friend class ::rocrand_cpp::normal_distribution;

1487 

1488  template<class T>

1489  friend class ::rocrand_cpp::lognormal_distribution;

1490 

1491  template<class T>

1492  friend class ::rocrand_cpp::poisson_distribution;

1494 };

1495 

1497 template<unsigned long long DefaultSeed>

1498 constexpr

1499  typename mrg31k3p_engine<DefaultSeed>::seed_type mrg31k3p_engine<DefaultSeed>::default_seed;

1501 

1507 template<unsigned long long DefaultSeed = ROCRAND_MRG32K3A_DEFAULT_SEED>

1508 class mrg32k3a_engine

1509 {

1510 public:

1512  typedef unsigned int result_type;

1514  typedef rocrand_ordering order_type;

1516  typedef unsigned long long offset_type;

1518  typedef unsigned long long seed_type;

1520  static constexpr seed_type default_seed = DefaultSeed;

1521 

1523  mrg32k3a_engine(seed_type seed_value = DefaultSeed,

1524  offset_type offset_value = 0,

1525  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

1526  {

1527  rocrand_status status;

1528  status = rocrand_create_generator(&m_generator, this->type());

1529  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1530  try

1531  {

1532  this->order(order_value);

1533  if(offset_value > 0)

1534  {

1535  this->offset(offset_value);

1536  }

1537  this->seed(seed_value);

1538  }

1539  catch(...)

1540  {

1541  (void)rocrand_destroy_generator(m_generator);

1542  throw;

1543  }

1544  }

1545 

1547  explicit mrg32k3a_engine(rocrand_generator& generator)

1548  : m_generator(generator)

1549  {

1550  if(generator == NULL)

1551  {

1552  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

1553  }

1554  generator = NULL;

1555  }

1556 

1557  mrg32k3a_engine(const mrg32k3a_engine&) = delete;

1558 

1559  mrg32k3a_engine& operator=(const mrg32k3a_engine&) = delete;

1560 

1562  mrg32k3a_engine(mrg32k3a_engine&& rhs) noexcept : m_generator(rhs.m_generator)

1563  {

1564  rhs.m_generator = nullptr;

1565  }

1566 

1568  mrg32k3a_engine& operator=(mrg32k3a_engine&& rhs) noexcept

1569  {

1570  rocrand_status status = rocrand_destroy_generator(m_generator);

1571  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

1572  (void)status;

1573 

1574  m_generator = rhs.m_generator;

1575  rhs.m_generator = nullptr;

1576  return *this;

1577  }

1578 

1580  ~mrg32k3a_engine() noexcept(false)

1581  {

1582  rocrand_status status = rocrand_destroy_generator(m_generator);

1583  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

1584  throw rocrand_cpp::error(status);

1585  }

1586 

1588  void stream(hipStream_t value)

1589  {

1590  rocrand_status status = rocrand_set_stream(m_generator, value);

1591  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1592  }

1593 

1595  void order(order_type value)

1596  {

1597  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

1598  if(status != ROCRAND_STATUS_SUCCESS)

1599  throw rocrand_cpp::error(status);

1600  }

1601 

1603  void offset(offset_type value)

1604  {

1605  rocrand_status status = rocrand_set_offset(this->m_generator, value);

1606  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1607  }

1608 

1610  void seed(seed_type value)

1611  {

1612  rocrand_status status = rocrand_set_seed(this->m_generator, value);

1613  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1614  }

1615 

1617  template<class Generator>

1618  void operator()(result_type * output, size_t size)

1619  {

1620  rocrand_status status;

1621  status = rocrand_generate(m_generator, output, size);

1622  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1623  }

1624 

1626  static constexpr result_type min()

1627  {

1628  return 1;

1629  }

1630 

1632  static constexpr result_type max()

1633  {

1634  return std::numeric_limits<unsigned int>::max();

1635  }

1636 

1638  static constexpr rocrand_rng_type type()

1639  {

1640  return ROCRAND_RNG_PSEUDO_MRG32K3A;

1641  }

1642 

1643 private:

1644  rocrand_generator m_generator;

1645 

1647  template<class T>

1648  friend class ::rocrand_cpp::uniform_int_distribution;

1649 

1650  template<class T>

1651  friend class ::rocrand_cpp::uniform_real_distribution;

1652 

1653  template<class T>

1654  friend class ::rocrand_cpp::normal_distribution;

1655 

1656  template<class T>

1657  friend class ::rocrand_cpp::lognormal_distribution;

1658 

1659  template<class T>

1660  friend class ::rocrand_cpp::poisson_distribution;

1662 };

1663 

1665 template<unsigned long long DefaultSeed>

1666 constexpr typename mrg32k3a_engine<DefaultSeed>::seed_type mrg32k3a_engine<DefaultSeed>::default_seed;

1668 

1675 template<unsigned long long DefaultSeed = 0>

1676 class mtgp32_engine

1677 {

1678 public:

1680  typedef unsigned int result_type;

1682  typedef rocrand_ordering order_type;

1684  typedef unsigned long long offset_type;

1686  typedef unsigned long long seed_type;

1688  static constexpr seed_type default_seed = DefaultSeed;

1689 

1698  mtgp32_engine(seed_type seed_value = DefaultSeed,

1699  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

1700  {

1701  rocrand_status status;

1702  status = rocrand_create_generator(&m_generator, this->type());

1703  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1704  try

1705  {

1706  this->order(order_value);

1707  this->seed(seed_value);

1708  }

1709  catch(...)

1710  {

1711  (void)rocrand_destroy_generator(m_generator);

1712  throw;

1713  }

1714  }

1715 

1717  explicit mtgp32_engine(rocrand_generator& generator)

1718  : m_generator(generator)

1719  {

1720  if(generator == NULL)

1721  {

1722  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

1723  }

1724  generator = NULL;

1725  }

1726 

1727  mtgp32_engine(const mtgp32_engine&) = delete;

1728 

1729  mtgp32_engine& operator=(const mtgp32_engine&) = delete;

1730 

1732  mtgp32_engine(mtgp32_engine&& rhs) noexcept : m_generator(rhs.m_generator)

1733  {

1734  rhs.m_generator = nullptr;

1735  }

1736 

1738  mtgp32_engine& operator=(mtgp32_engine&& rhs) noexcept

1739  {

1740  rocrand_status status = rocrand_destroy_generator(m_generator);

1741  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

1742  (void)status;

1743 

1744  m_generator = rhs.m_generator;

1745  rhs.m_generator = nullptr;

1746  return *this;

1747  }

1748 

1750  ~mtgp32_engine() noexcept(false)

1751  {

1752  rocrand_status status = rocrand_destroy_generator(m_generator);

1753  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

1754  throw rocrand_cpp::error(status);

1755  }

1756 

1758  void stream(hipStream_t value)

1759  {

1760  rocrand_status status = rocrand_set_stream(m_generator, value);

1761  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1762  }

1763 

1765  void order(order_type value)

1766  {

1767  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

1768  if(status != ROCRAND_STATUS_SUCCESS)

1769  throw rocrand_cpp::error(status);

1770  }

1771 

1773  void seed(seed_type value)

1774  {

1775  rocrand_status status = rocrand_set_seed(this->m_generator, value);

1776  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1777  }

1778 

1780  template<class Generator>

1781  void operator()(result_type * output, size_t size)

1782  {

1783  rocrand_status status;

1784  status = rocrand_generate(m_generator, output, size);

1785  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

1786  }

1787 

1789  static constexpr result_type min()

1790  {

1791  return 0;

1792  }

1793 

1795  static constexpr result_type max()

1796  {

1797  return std::numeric_limits<unsigned int>::max();

1798  }

1799 

1801  static constexpr rocrand_rng_type type()

1802  {

1803  return ROCRAND_RNG_PSEUDO_MTGP32;

1804  }

1805 

1806 private:

1807  rocrand_generator m_generator;

1808 

1810  template<class T>

1811  friend class ::rocrand_cpp::uniform_int_distribution;

1812 

1813  template<class T>

1814  friend class ::rocrand_cpp::uniform_real_distribution;

1815 

1816  template<class T>

1817  friend class ::rocrand_cpp::normal_distribution;

1818 

1819  template<class T>

1820  friend class ::rocrand_cpp::lognormal_distribution;

1821 

1822  template<class T>

1823  friend class ::rocrand_cpp::poisson_distribution;

1825 };

1826 

1828 template<unsigned long long DefaultSeed>

1829 constexpr typename mtgp32_engine<DefaultSeed>::seed_type mtgp32_engine<DefaultSeed>::default_seed;

1831 

1837 template<unsigned int DefaultSeedX = ROCRAND_LFSR113_DEFAULT_SEED_X,

1838  unsigned int DefaultSeedY = ROCRAND_LFSR113_DEFAULT_SEED_Y,

1839  unsigned int DefaultSeedZ = ROCRAND_LFSR113_DEFAULT_SEED_Z,

1840  unsigned int DefaultSeedW = ROCRAND_LFSR113_DEFAULT_SEED_W>

1841 class lfsr113_engine

1842 {

1843 public:

1845  typedef unsigned int result_type;

1847  typedef rocrand_ordering order_type;

1849  typedef uint4 seed_type;

1851  static constexpr seed_type default_seed

1852  = {DefaultSeedX, DefaultSeedY, DefaultSeedZ, DefaultSeedW};

1853 

1862  lfsr113_engine(seed_type seed_value = {DefaultSeedX, DefaultSeedY, DefaultSeedZ, DefaultSeedW},

1863  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

1864  {

1865  rocrand_status status;

1866  status = rocrand_create_generator(&m_generator, this->type());

1867  if(status != ROCRAND_STATUS_SUCCESS)

1868  throw rocrand_cpp::error(status);

1869  try

1870  {

1871  this->order(order_value);

1872  this->seed(seed_value);

1873  }

1874  catch(...)

1875  {

1876  (void)rocrand_destroy_generator(m_generator);

1877  throw;

1878  }

1879  }

1880 

1882  lfsr113_engine(unsigned long long seed_value,

1883  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

1884  {

1885  rocrand_status status;

1886  status = rocrand_create_generator(&m_generator, this->type());

1887  if(status != ROCRAND_STATUS_SUCCESS)

1888  throw rocrand_cpp::error(status);

1889  try

1890  {

1891  this->order(order_value);

1892  this->seed(seed_value);

1893  }

1894  catch(...)

1895  {

1896  (void)rocrand_destroy_generator(m_generator);

1897  throw;

1898  }

1899  }

1900 

1902  explicit lfsr113_engine(rocrand_generator& generator) : m_generator(generator)

1903  {

1904  if(generator == NULL)

1905  {

1906  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

1907  }

1908  generator = NULL;

1909  }

1910 

1911  lfsr113_engine(const lfsr113_engine&) = delete;

1912 

1913  lfsr113_engine& operator=(const lfsr113_engine&) = delete;

1914 

1916  lfsr113_engine(lfsr113_engine&& rhs) noexcept : m_generator(rhs.m_generator)

1917  {

1918  rhs.m_generator = nullptr;

1919  }

1920 

1922  lfsr113_engine& operator=(lfsr113_engine&& rhs) noexcept

1923  {

1924  rocrand_status status = rocrand_destroy_generator(m_generator);

1925  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

1926  (void)status;

1927 

1928  m_generator = rhs.m_generator;

1929  rhs.m_generator = nullptr;

1930  return *this;

1931  }

1932 

1934  ~lfsr113_engine() noexcept(false)

1935  {

1936  rocrand_status status = rocrand_destroy_generator(m_generator);

1937  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

1938  throw rocrand_cpp::error(status);

1939  }

1940 

1942  void stream(hipStream_t value)

1943  {

1944  rocrand_status status = rocrand_set_stream(m_generator, value);

1945  if(status != ROCRAND_STATUS_SUCCESS)

1946  throw rocrand_cpp::error(status);

1947  }

1948 

1950  void order(order_type value)

1951  {

1952  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

1953  if(status != ROCRAND_STATUS_SUCCESS)

1954  throw rocrand_cpp::error(status);

1955  }

1956 

1958  void seed(unsigned long long value)

1959  {

1960  rocrand_status status = rocrand_set_seed(this->m_generator, value);

1961  if(status != ROCRAND_STATUS_SUCCESS)

1962  throw rocrand_cpp::error(status);

1963  }

1964 

1966  void seed(seed_type value)

1967  {

1968  rocrand_status status = rocrand_set_seed_uint4(this->m_generator, value);

1969  if(status != ROCRAND_STATUS_SUCCESS)

1970  throw rocrand_cpp::error(status);

1971  }

1972 

1974  template<class Generator>

1975  void operator()(result_type* output, size_t size)

1976  {

1977  rocrand_status status;

1978  status = rocrand_generate(m_generator, output, size);

1979  if(status != ROCRAND_STATUS_SUCCESS)

1980  throw rocrand_cpp::error(status);

1981  }

1982 

1984  static constexpr result_type min()

1985  {

1986  return 0;

1987  }

1988 

1990  static constexpr result_type max()

1991  {

1992  return std::numeric_limits<unsigned int>::max();

1993  }

1994 

1996  static constexpr rocrand_rng_type type()

1997  {

1998  return ROCRAND_RNG_PSEUDO_LFSR113;

1999  }

2000 

2001 private:

2002  rocrand_generator m_generator;

2003 

2005  template<class T>

2006  friend class ::rocrand_cpp::uniform_int_distribution;

2007 

2008  template<class T>

2009  friend class ::rocrand_cpp::uniform_real_distribution;

2010 

2011  template<class T>

2012  friend class ::rocrand_cpp::normal_distribution;

2013 

2014  template<class T>

2015  friend class ::rocrand_cpp::lognormal_distribution;

2016 

2017  template<class T>

2018  friend class ::rocrand_cpp::poisson_distribution;

2020 };

2021 

2023 template<unsigned int DefaultSeedX,

2024  unsigned int DefaultSeedY,

2025  unsigned int DefaultSeedZ,

2026  unsigned int DefaultSeedW>

2027 constexpr typename lfsr113_engine<DefaultSeedX, DefaultSeedY, DefaultSeedZ, DefaultSeedW>::seed_type

2028  lfsr113_engine<DefaultSeedX, DefaultSeedY, DefaultSeedZ, DefaultSeedW>::default_seed;

2030 

2037 template<unsigned long long DefaultSeed = 0ULL>

2038 class mt19937_engine

2039 {

2040 public:

2042  typedef unsigned int result_type;

2044  typedef rocrand_ordering order_type;

2046  typedef unsigned long long seed_type;

2048  static constexpr seed_type default_seed = DefaultSeed;

2049 

2058  mt19937_engine(seed_type seed_value = DefaultSeed,

2059  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

2060  {

2061  rocrand_status status;

2062  status = rocrand_create_generator(&m_generator, this->type());

2063  if(status != ROCRAND_STATUS_SUCCESS)

2064  throw rocrand_cpp::error(status);

2065  try

2066  {

2067  this->order(order_value);

2068  this->seed(seed_value);

2069  }

2070  catch(...)

2071  {

2072  (void)rocrand_destroy_generator(m_generator);

2073  throw;

2074  }

2075  }

2076 

2078  explicit mt19937_engine(rocrand_generator& generator) : m_generator(generator)

2079  {

2080  if(generator == NULL)

2081  {

2082  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

2083  }

2084  generator = NULL;

2085  }

2086 

2087  mt19937_engine(const mt19937_engine&) = delete;

2088 

2089  mt19937_engine& operator=(const mt19937_engine&) = delete;

2090 

2092  mt19937_engine(mt19937_engine&& rhs) noexcept : m_generator(rhs.m_generator)

2093  {

2094  rhs.m_generator = nullptr;

2095  }

2096 

2098  mt19937_engine& operator=(mt19937_engine&& rhs) noexcept

2099  {

2100  rocrand_status status = rocrand_destroy_generator(m_generator);

2101  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

2102  (void)status;

2103 

2104  m_generator = rhs.m_generator;

2105  rhs.m_generator = nullptr;

2106  return *this;

2107  }

2108 

2110  ~mt19937_engine() noexcept(false)

2111  {

2112  rocrand_status status = rocrand_destroy_generator(m_generator);

2113  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

2114  throw rocrand_cpp::error(status);

2115  }

2116 

2118  void stream(hipStream_t value)

2119  {

2120  rocrand_status status = rocrand_set_stream(m_generator, value);

2121  if(status != ROCRAND_STATUS_SUCCESS)

2122  throw rocrand_cpp::error(status);

2123  }

2124 

2126  void order(order_type value)

2127  {

2128  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

2129  if(status != ROCRAND_STATUS_SUCCESS)

2130  throw rocrand_cpp::error(status);

2131  }

2132 

2134  void seed(seed_type value)

2135  {

2136  rocrand_status status = rocrand_set_seed(this->m_generator, value);

2137  if(status != ROCRAND_STATUS_SUCCESS)

2138  throw rocrand_cpp::error(status);

2139  }

2140 

2142  template<class Generator>

2143  void operator()(result_type* output, size_t size)

2144  {

2145  rocrand_status status;

2146  status = rocrand_generate(m_generator, output, size);

2147  if(status != ROCRAND_STATUS_SUCCESS)

2148  throw rocrand_cpp::error(status);

2149  }

2150 

2152  static constexpr result_type min()

2153  {

2154  return 0;

2155  }

2156 

2158  static constexpr result_type max()

2159  {

2160  return std::numeric_limits<unsigned int>::max();

2161  }

2162 

2164  static constexpr rocrand_rng_type type()

2165  {

2166  return ROCRAND_RNG_PSEUDO_MT19937;

2167  }

2168 

2169 private:

2170  rocrand_generator m_generator;

2171 

2173  template<class T>

2174  friend class ::rocrand_cpp::uniform_int_distribution;

2175 

2176  template<class T>

2177  friend class ::rocrand_cpp::uniform_real_distribution;

2178 

2179  template<class T>

2180  friend class ::rocrand_cpp::normal_distribution;

2181 

2182  template<class T>

2183  friend class ::rocrand_cpp::lognormal_distribution;

2184 

2185  template<class T>

2186  friend class ::rocrand_cpp::poisson_distribution;

2188 };

2189 

2191 template<unsigned long long DefaultSeed>

2192 constexpr typename mt19937_engine<DefaultSeed>::seed_type mt19937_engine<DefaultSeed>::default_seed;

2194 

2200 template<unsigned int DefaultNumDimensions = 1>

2201 class sobol32_engine

2202 {

2203 public:

2205  typedef unsigned int result_type;

2207  typedef rocrand_ordering order_type;

2209  typedef unsigned long long offset_type;

2214  typedef unsigned int dimensions_num_type;

2216  static constexpr dimensions_num_type default_num_dimensions = DefaultNumDimensions;

2217 

2225  sobol32_engine(dimensions_num_type num_of_dimensions = DefaultNumDimensions,

2226  offset_type offset_value = 0,

2227  order_type order_value = ROCRAND_ORDERING_QUASI_DEFAULT)

2228  {

2229  rocrand_status status;

2230  status = rocrand_create_generator(&m_generator, this->type());

2231  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

2232  try

2233  {

2234  this->order(order_value);

2235  if(offset_value > 0)

2236  {

2237  this->offset(offset_value);

2238  }

2239  this->dimensions(num_of_dimensions);

2240  }

2241  catch(...)

2242  {

2243  (void)rocrand_destroy_generator(m_generator);

2244  throw;

2245  }

2246  }

2247 

2249  explicit sobol32_engine(rocrand_generator& generator)

2250  : m_generator(generator)

2251  {

2252  if(generator == NULL)

2253  {

2254  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

2255  }

2256  generator = NULL;

2257  }

2258 

2259  sobol32_engine(const sobol32_engine&) = delete;

2260 

2261  sobol32_engine& operator=(const sobol32_engine&) = delete;

2262 

2264  sobol32_engine(sobol32_engine&& rhs) noexcept : m_generator(rhs.m_generator)

2265  {

2266  rhs.m_generator = nullptr;

2267  }

2268 

2270  sobol32_engine& operator=(sobol32_engine&& rhs) noexcept

2271  {

2272  rocrand_status status = rocrand_destroy_generator(m_generator);

2273  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

2274  (void)status;

2275 

2276  m_generator = rhs.m_generator;

2277  rhs.m_generator = nullptr;

2278  return *this;

2279  }

2280 

2282  ~sobol32_engine() noexcept(false)

2283  {

2284  rocrand_status status = rocrand_destroy_generator(m_generator);

2285  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

2286  throw rocrand_cpp::error(status);

2287  }

2288 

2290  void stream(hipStream_t value)

2291  {

2292  rocrand_status status = rocrand_set_stream(m_generator, value);

2293  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

2294  }

2295 

2297  void order(order_type value)

2298  {

2299  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

2300  if(status != ROCRAND_STATUS_SUCCESS)

2301  throw rocrand_cpp::error(status);

2302  }

2303 

2305  void offset(offset_type value)

2306  {

2307  rocrand_status status = rocrand_set_offset(this->m_generator, value);

2308  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

2309  }

2310 

2321  void dimensions(dimensions_num_type value)

2322  {

2323  rocrand_status status =

2324  rocrand_set_quasi_random_generator_dimensions(this->m_generator, value);

2325  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

2326  }

2327 

2343  template<class Generator>

2344  void operator()(result_type * output, size_t size)

2345  {

2346  rocrand_status status;

2347  status = rocrand_generate(m_generator, output, size);

2348  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

2349  }

2350 

2352  static constexpr result_type min()

2353  {

2354  return 0;

2355  }

2356 

2358  static constexpr result_type max()

2359  {

2360  return std::numeric_limits<unsigned int>::max();

2361  }

2362 

2364  static constexpr rocrand_rng_type type()

2365  {

2366  return ROCRAND_RNG_QUASI_SOBOL32;

2367  }

2368 

2369 private:

2370  rocrand_generator m_generator;

2371 

2373  template<class T>

2374  friend class ::rocrand_cpp::uniform_int_distribution;

2375 

2376  template<class T>

2377  friend class ::rocrand_cpp::uniform_real_distribution;

2378 

2379  template<class T>

2380  friend class ::rocrand_cpp::normal_distribution;

2381 

2382  template<class T>

2383  friend class ::rocrand_cpp::lognormal_distribution;

2384 

2385  template<class T>

2386  friend class ::rocrand_cpp::poisson_distribution;

2388 };

2389 

2391 template<unsigned int DefaultNumDimensions>

2392 constexpr typename sobol32_engine<DefaultNumDimensions>::dimensions_num_type

2393  sobol32_engine<DefaultNumDimensions>::default_num_dimensions;

2395 

2401 template<unsigned int DefaultNumDimensions = 1>

2402 class scrambled_sobol32_engine

2403 {

2404 public:

2406  typedef unsigned int result_type;

2408  typedef unsigned long long offset_type;

2410  typedef rocrand_ordering order_type;

2415  typedef unsigned int dimensions_num_type;

2417  static constexpr dimensions_num_type default_num_dimensions = DefaultNumDimensions;

2418 

2426  scrambled_sobol32_engine(dimensions_num_type num_of_dimensions = DefaultNumDimensions,

2427  offset_type offset_value = 0,

2428  order_type order_value = ROCRAND_ORDERING_QUASI_DEFAULT)

2429  {

2430  rocrand_status status;

2431  status = rocrand_create_generator(&m_generator, this->type());

2432  if(status != ROCRAND_STATUS_SUCCESS)

2433  throw rocrand_cpp::error(status);

2434  try

2435  {

2436  this->order(order_value);

2437  if(offset_value > 0)

2438  {

2439  this->offset(offset_value);

2440  }

2441  this->dimensions(num_of_dimensions);

2442  }

2443  catch(...)

2444  {

2445  (void)rocrand_destroy_generator(m_generator);

2446  throw;

2447  }

2448  }

2449 

2451  explicit scrambled_sobol32_engine(rocrand_generator& generator) : m_generator(generator)

2452  {

2453  if(generator == NULL)

2454  {

2455  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

2456  }

2457  generator = NULL;

2458  }

2459 

2460  scrambled_sobol32_engine(const scrambled_sobol32_engine&) = delete;

2461 

2462  scrambled_sobol32_engine& operator=(const scrambled_sobol32_engine&) = delete;

2463 

2465  scrambled_sobol32_engine(scrambled_sobol32_engine&& rhs) noexcept : m_generator(rhs.m_generator)

2466  {

2467  rhs.m_generator = nullptr;

2468  }

2469 

2471  scrambled_sobol32_engine& operator=(scrambled_sobol32_engine&& rhs) noexcept

2472  {

2473  rocrand_status status = rocrand_destroy_generator(m_generator);

2474  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

2475  (void)status;

2476 

2477  m_generator = rhs.m_generator;

2478  rhs.m_generator = nullptr;

2479  return *this;

2480  }

2481 

2483  ~scrambled_sobol32_engine() noexcept(false)

2484  {

2485  rocrand_status status = rocrand_destroy_generator(m_generator);

2486  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

2487  throw rocrand_cpp::error(status);

2488  }

2489 

2491  void stream(hipStream_t value)

2492  {

2493  rocrand_status status = rocrand_set_stream(m_generator, value);

2494  if(status != ROCRAND_STATUS_SUCCESS)

2495  throw rocrand_cpp::error(status);

2496  }

2497 

2499  void order(order_type value)

2500  {

2501  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

2502  if(status != ROCRAND_STATUS_SUCCESS)

2503  throw rocrand_cpp::error(status);

2504  }

2505 

2507  void offset(offset_type value)

2508  {

2509  rocrand_status status = rocrand_set_offset(this->m_generator, value);

2510  if(status != ROCRAND_STATUS_SUCCESS)

2511  throw rocrand_cpp::error(status);

2512  }

2513 

2524  void dimensions(dimensions_num_type value)

2525  {

2526  rocrand_status status

2527  = rocrand_set_quasi_random_generator_dimensions(this->m_generator, value);

2528  if(status != ROCRAND_STATUS_SUCCESS)

2529  throw rocrand_cpp::error(status);

2530  }

2531 

2547  template<class Generator>

2548  void operator()(result_type* output, size_t size)

2549  {

2550  rocrand_status status;

2551  status = rocrand_generate(m_generator, output, size);

2552  if(status != ROCRAND_STATUS_SUCCESS)

2553  throw rocrand_cpp::error(status);

2554  }

2555 

2557  static constexpr result_type min()

2558  {

2559  return 0;

2560  }

2561 

2563  static constexpr result_type max()

2564  {

2565  return std::numeric_limits<unsigned int>::max();

2566  }

2567 

2569  static constexpr rocrand_rng_type type()

2570  {

2571  return ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL32;

2572  }

2573 

2574 private:

2575  rocrand_generator m_generator;

2576 

2578  template<class T>

2579  friend class ::rocrand_cpp::uniform_int_distribution;

2580 

2581  template<class T>

2582  friend class ::rocrand_cpp::uniform_real_distribution;

2583 

2584  template<class T>

2585  friend class ::rocrand_cpp::normal_distribution;

2586 

2587  template<class T>

2588  friend class ::rocrand_cpp::lognormal_distribution;

2589 

2590  template<class T>

2591  friend class ::rocrand_cpp::poisson_distribution;

2593 };

2594 

2596 template<unsigned int DefaultNumDimensions>

2597 constexpr typename scrambled_sobol32_engine<DefaultNumDimensions>::dimensions_num_type

2598  scrambled_sobol32_engine<DefaultNumDimensions>::default_num_dimensions;

2600 

2606 template<unsigned int DefaultNumDimensions = 1>

2607 class sobol64_engine

2608 {

2609 public:

2611  typedef unsigned long long int result_type;

2613  typedef unsigned long long int offset_type;

2615  typedef rocrand_ordering order_type;

2620  typedef unsigned int dimensions_num_type;

2622  static constexpr dimensions_num_type default_num_dimensions = DefaultNumDimensions;

2623 

2631  sobol64_engine(dimensions_num_type num_of_dimensions = DefaultNumDimensions,

2632  offset_type offset_value = 0,

2633  order_type order_value = ROCRAND_ORDERING_QUASI_DEFAULT)

2634  {

2635  rocrand_status status;

2636  status = rocrand_create_generator(&m_generator, this->type());

2637  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

2638  try

2639  {

2640  this->order(order_value);

2641  if(offset_value > 0)

2642  {

2643  this->offset(offset_value);

2644  }

2645  this->dimensions(num_of_dimensions);

2646  }

2647  catch(...)

2648  {

2649  (void)rocrand_destroy_generator(m_generator);

2650  throw;

2651  }

2652  }

2653 

2655  explicit sobol64_engine(rocrand_generator& generator)

2656  : m_generator(generator)

2657  {

2658  if(generator == NULL)

2659  {

2660  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

2661  }

2662  generator = NULL;

2663  }

2664 

2665  sobol64_engine(const sobol64_engine&) = delete;

2666 

2667  sobol64_engine& operator=(const sobol64_engine&) = delete;

2668 

2670  sobol64_engine(sobol64_engine&& rhs) noexcept : m_generator(rhs.m_generator)

2671  {

2672  rhs.m_generator = nullptr;

2673  }

2674 

2676  sobol64_engine& operator=(sobol64_engine&& rhs) noexcept

2677  {

2678  rocrand_status status = rocrand_destroy_generator(m_generator);

2679  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

2680  (void)status;

2681 

2682  m_generator = rhs.m_generator;

2683  rhs.m_generator = nullptr;

2684  return *this;

2685  }

2686 

2688  ~sobol64_engine() noexcept(false)

2689  {

2690  rocrand_status status = rocrand_destroy_generator(m_generator);

2691  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

2692  throw rocrand_cpp::error(status);

2693  }

2694 

2696  void stream(hipStream_t value)

2697  {

2698  rocrand_status status = rocrand_set_stream(m_generator, value);

2699  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

2700  }

2701 

2703  void order(order_type value)

2704  {

2705  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

2706  if(status != ROCRAND_STATUS_SUCCESS)

2707  throw rocrand_cpp::error(status);

2708  }

2709 

2711  void offset(offset_type value)

2712  {

2713  rocrand_status status = rocrand_set_offset(this->m_generator, value);

2714  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

2715  }

2716 

2727  void dimensions(dimensions_num_type value)

2728  {

2729  rocrand_status status =

2730  rocrand_set_quasi_random_generator_dimensions(this->m_generator, value);

2731  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

2732  }

2733 

2749  template<class Generator>

2750  void operator()(result_type * output, size_t size)

2751  {

2752  rocrand_status status;

2753  status = rocrand_generate_long_long(m_generator, output, size);

2754  if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);

2755  }

2756 

2758  static constexpr result_type min()

2759  {

2760  return 0;

2761  }

2762 

2764  static constexpr result_type max()

2765  {

2766  return std::numeric_limits<result_type>::max();

2767  }

2768 

2770  static constexpr rocrand_rng_type type()

2771  {

2772  return ROCRAND_RNG_QUASI_SOBOL64;

2773  }

2774 

2775 private:

2776  rocrand_generator m_generator;

2777 

2779  template<class T>

2780  friend class ::rocrand_cpp::uniform_int_distribution;

2781 

2782  template<class T>

2783  friend class ::rocrand_cpp::uniform_real_distribution;

2784 

2785  template<class T>

2786  friend class ::rocrand_cpp::normal_distribution;

2787 

2788  template<class T>

2789  friend class ::rocrand_cpp::lognormal_distribution;

2790 

2791  template<class T>

2792  friend class ::rocrand_cpp::poisson_distribution;

2794 };

2795 

2797 template<unsigned int DefaultNumDimensions>

2798 constexpr typename sobol64_engine<DefaultNumDimensions>::dimensions_num_type

2799  sobol64_engine<DefaultNumDimensions>::default_num_dimensions;

2801 

2807 template<unsigned int DefaultNumDimensions = 1>

2808 class scrambled_sobol64_engine

2809 {

2810 public:

2812  typedef unsigned long long int result_type;

2814  typedef rocrand_ordering order_type;

2816  typedef unsigned long long int offset_type;

2821  typedef unsigned int dimensions_num_type;

2823  static constexpr dimensions_num_type default_num_dimensions = DefaultNumDimensions;

2824 

2832  scrambled_sobol64_engine(dimensions_num_type num_of_dimensions = DefaultNumDimensions,

2833  offset_type offset_value = 0,

2834  order_type order_value = ROCRAND_ORDERING_QUASI_DEFAULT)

2835  {

2836  rocrand_status status;

2837  status = rocrand_create_generator(&m_generator, this->type());

2838  if(status != ROCRAND_STATUS_SUCCESS)

2839  throw rocrand_cpp::error(status);

2840  try

2841  {

2842  this->order(order_value);

2843  if(offset_value > 0)

2844  {

2845  this->offset(offset_value);

2846  }

2847  this->dimensions(num_of_dimensions);

2848  }

2849  catch(...)

2850  {

2851  (void)rocrand_destroy_generator(m_generator);

2852  throw;

2853  }

2854  }

2855 

2857  explicit scrambled_sobol64_engine(rocrand_generator& generator) : m_generator(generator)

2858  {

2859  if(generator == NULL)

2860  {

2861  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

2862  }

2863  generator = NULL;

2864  }

2865 

2866  scrambled_sobol64_engine(const scrambled_sobol64_engine&) = delete;

2867 

2868  scrambled_sobol64_engine& operator=(const scrambled_sobol64_engine&) = delete;

2869 

2871  scrambled_sobol64_engine(scrambled_sobol64_engine&& rhs) noexcept : m_generator(rhs.m_generator)

2872  {

2873  rhs.m_generator = nullptr;

2874  }

2875 

2877  scrambled_sobol64_engine& operator=(scrambled_sobol64_engine&& rhs) noexcept

2878  {

2879  rocrand_status status = rocrand_destroy_generator(m_generator);

2880  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

2881  (void)status;

2882 

2883  m_generator = rhs.m_generator;

2884  rhs.m_generator = nullptr;

2885  return *this;

2886  }

2887 

2889  ~scrambled_sobol64_engine() noexcept(false)

2890  {

2891  rocrand_status status = rocrand_destroy_generator(m_generator);

2892  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

2893  throw rocrand_cpp::error(status);

2894  }

2895 

2897  void stream(hipStream_t value)

2898  {

2899  rocrand_status status = rocrand_set_stream(m_generator, value);

2900  if(status != ROCRAND_STATUS_SUCCESS)

2901  throw rocrand_cpp::error(status);

2902  }

2903 

2905  void order(order_type value)

2906  {

2907  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

2908  if(status != ROCRAND_STATUS_SUCCESS)

2909  throw rocrand_cpp::error(status);

2910  }

2911 

2913  void offset(offset_type value)

2914  {

2915  rocrand_status status = rocrand_set_offset(this->m_generator, value);

2916  if(status != ROCRAND_STATUS_SUCCESS)

2917  throw rocrand_cpp::error(status);

2918  }

2919 

2930  void dimensions(dimensions_num_type value)

2931  {

2932  rocrand_status status

2933  = rocrand_set_quasi_random_generator_dimensions(this->m_generator, value);

2934  if(status != ROCRAND_STATUS_SUCCESS)

2935  throw rocrand_cpp::error(status);

2936  }

2937 

2953  template<class Generator>

2954  void operator()(result_type* output, size_t size)

2955  {

2956  rocrand_status status;

2957  status = rocrand_generate_long_long(m_generator, output, size);

2958  if(status != ROCRAND_STATUS_SUCCESS)

2959  throw rocrand_cpp::error(status);

2960  }

2961 

2963  static constexpr result_type min()

2964  {

2965  return 0;

2966  }

2967 

2969  static constexpr result_type max()

2970  {

2971  return std::numeric_limits<result_type>::max();

2972  }

2973 

2975  static constexpr rocrand_rng_type type()

2976  {

2977  return ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL64;

2978  }

2979 

2980 private:

2981  rocrand_generator m_generator;

2982 

2984  template<class T>

2985  friend class ::rocrand_cpp::uniform_int_distribution;

2986 

2987  template<class T>

2988  friend class ::rocrand_cpp::uniform_real_distribution;

2989 

2990  template<class T>

2991  friend class ::rocrand_cpp::normal_distribution;

2992 

2993  template<class T>

2994  friend class ::rocrand_cpp::lognormal_distribution;

2995 

2996  template<class T>

2997  friend class ::rocrand_cpp::poisson_distribution;

2999 };

3000 

3002 template<unsigned int DefaultNumDimensions>

3003 constexpr typename scrambled_sobol64_engine<DefaultNumDimensions>::dimensions_num_type

3004  scrambled_sobol64_engine<DefaultNumDimensions>::default_num_dimensions;

3006 

3011 template<unsigned long long DefaultSeed = 0>

3012 class threefry2x32_20_engine

3013 {

3014 public:

3016  typedef unsigned int result_type;

3018  typedef rocrand_ordering order_type;

3020  typedef unsigned long long offset_type;

3022  typedef unsigned long long seed_type;

3024  static constexpr seed_type default_seed = DefaultSeed;

3025 

3027  threefry2x32_20_engine(seed_type seed_value = DefaultSeed,

3028  offset_type offset_value = 0,

3029  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

3030  {

3031  rocrand_status status;

3032  status = rocrand_create_generator(&m_generator, this->type());

3033  if(status != ROCRAND_STATUS_SUCCESS)

3034  throw rocrand_cpp::error(status);

3035  try

3036  {

3037  if(offset_value > 0)

3038  {

3039  this->offset(offset_value);

3040  }

3041  this->order(order_value);

3042  this->seed(seed_value);

3043  }

3044  catch(...)

3045  {

3046  (void)rocrand_destroy_generator(m_generator);

3047  throw;

3048  }

3049  }

3050 

3052  explicit threefry2x32_20_engine(rocrand_generator& generator) : m_generator(generator)

3053  {

3054  if(generator == NULL)

3055  {

3056  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

3057  }

3058  generator = NULL;

3059  }

3060 

3061  threefry2x32_20_engine(const threefry2x32_20_engine&) = delete;

3062 

3063  threefry2x32_20_engine& operator=(const threefry2x32_20_engine&) = delete;

3064 

3066  threefry2x32_20_engine(threefry2x32_20_engine&& rhs) noexcept : m_generator(rhs.m_generator)

3067  {

3068  rhs.m_generator = nullptr;

3069  }

3070 

3072  threefry2x32_20_engine& operator=(threefry2x32_20_engine&& rhs) noexcept

3073  {

3074  rocrand_status status = rocrand_destroy_generator(m_generator);

3075  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

3076  (void)status;

3077 

3078  m_generator = rhs.m_generator;

3079  rhs.m_generator = nullptr;

3080  return *this;

3081  }

3082 

3084  ~threefry2x32_20_engine() noexcept(false)

3085  {

3086  rocrand_status status = rocrand_destroy_generator(m_generator);

3087  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

3088  throw rocrand_cpp::error(status);

3089  }

3090 

3092  void stream(hipStream_t value)

3093  {

3094  rocrand_status status = rocrand_set_stream(m_generator, value);

3095  if(status != ROCRAND_STATUS_SUCCESS)

3096  throw rocrand_cpp::error(status);

3097  }

3098 

3100  void order(order_type value)

3101  {

3102  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

3103  if(status != ROCRAND_STATUS_SUCCESS)

3104  throw rocrand_cpp::error(status);

3105  }

3106 

3108  void offset(offset_type value)

3109  {

3110  rocrand_status status = rocrand_set_offset(this->m_generator, value);

3111  if(status != ROCRAND_STATUS_SUCCESS)

3112  throw rocrand_cpp::error(status);

3113  }

3114 

3116  void seed(seed_type value)

3117  {

3118  rocrand_status status = rocrand_set_seed(this->m_generator, value);

3119  if(status != ROCRAND_STATUS_SUCCESS)

3120  throw rocrand_cpp::error(status);

3121  }

3122 

3124  template<class Generator>

3125  void operator()(result_type* output, size_t size)

3126  {

3127  rocrand_status status;

3128  status = rocrand_generate(m_generator, output, size);

3129  if(status != ROCRAND_STATUS_SUCCESS)

3130  throw rocrand_cpp::error(status);

3131  }

3132 

3134  static constexpr result_type min()

3135  {

3136  return 0;

3137  }

3138 

3140  static constexpr result_type max()

3141  {

3142  return std::numeric_limits<unsigned int>::max();

3143  }

3144 

3146  static constexpr rocrand_rng_type type()

3147  {

3148  return ROCRAND_RNG_PSEUDO_THREEFRY2_32_20;

3149  }

3150 

3151 private:

3152  rocrand_generator m_generator;

3153 

3155  template<class T>

3156  friend class ::rocrand_cpp::uniform_int_distribution;

3157 

3158  template<class T>

3159  friend class ::rocrand_cpp::uniform_real_distribution;

3160 

3161  template<class T>

3162  friend class ::rocrand_cpp::normal_distribution;

3163 

3164  template<class T>

3165  friend class ::rocrand_cpp::lognormal_distribution;

3166 

3167  template<class T>

3168  friend class ::rocrand_cpp::poisson_distribution;

3170 };

3171 

3173 template<unsigned long long DefaultSeed>

3174 constexpr typename threefry2x32_20_engine<DefaultSeed>::seed_type

3175  threefry2x32_20_engine<DefaultSeed>::default_seed;

3177 

3182 template<unsigned long long DefaultSeed = 0>

3183 class threefry2x64_20_engine

3184 {

3185 public:

3187  typedef unsigned long long result_type;

3189  typedef rocrand_ordering order_type;

3191  typedef unsigned long long offset_type;

3193  typedef unsigned long long seed_type;

3195  static constexpr seed_type default_seed = DefaultSeed;

3196 

3198  threefry2x64_20_engine(seed_type seed_value = DefaultSeed,

3199  offset_type offset_value = 0,

3200  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

3201  {

3202  rocrand_status status;

3203  status = rocrand_create_generator(&m_generator, this->type());

3204  if(status != ROCRAND_STATUS_SUCCESS)

3205  throw rocrand_cpp::error(status);

3206  try

3207  {

3208  if(offset_value > 0)

3209  {

3210  this->offset(offset_value);

3211  }

3212  this->order(order_value);

3213  this->seed(seed_value);

3214  }

3215  catch(...)

3216  {

3217  (void)rocrand_destroy_generator(m_generator);

3218  throw;

3219  }

3220  }

3221 

3223  explicit threefry2x64_20_engine(rocrand_generator& generator) : m_generator(generator)

3224  {

3225  if(generator == NULL)

3226  {

3227  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

3228  }

3229  generator = NULL;

3230  }

3231 

3232  threefry2x64_20_engine(const threefry2x64_20_engine&) = delete;

3233 

3234  threefry2x64_20_engine& operator=(const threefry2x64_20_engine&) = delete;

3235 

3237  threefry2x64_20_engine(threefry2x64_20_engine&& rhs) noexcept : m_generator(rhs.m_generator)

3238  {

3239  rhs.m_generator = nullptr;

3240  }

3241 

3243  threefry2x64_20_engine& operator=(threefry2x64_20_engine&& rhs) noexcept

3244  {

3245  rocrand_status status = rocrand_destroy_generator(m_generator);

3246  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

3247  (void)status;

3248 

3249  m_generator = rhs.m_generator;

3250  rhs.m_generator = nullptr;

3251  return *this;

3252  }

3253 

3255  ~threefry2x64_20_engine() noexcept(false)

3256  {

3257  rocrand_status status = rocrand_destroy_generator(m_generator);

3258  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

3259  throw rocrand_cpp::error(status);

3260  }

3261 

3263  void stream(hipStream_t value)

3264  {

3265  rocrand_status status = rocrand_set_stream(m_generator, value);

3266  if(status != ROCRAND_STATUS_SUCCESS)

3267  throw rocrand_cpp::error(status);

3268  }

3269 

3271  void order(order_type value)

3272  {

3273  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

3274  if(status != ROCRAND_STATUS_SUCCESS)

3275  throw rocrand_cpp::error(status);

3276  }

3277 

3279  void offset(offset_type value)

3280  {

3281  rocrand_status status = rocrand_set_offset(this->m_generator, value);

3282  if(status != ROCRAND_STATUS_SUCCESS)

3283  throw rocrand_cpp::error(status);

3284  }

3285 

3287  void seed(seed_type value)

3288  {

3289  rocrand_status status = rocrand_set_seed(this->m_generator, value);

3290  if(status != ROCRAND_STATUS_SUCCESS)

3291  throw rocrand_cpp::error(status);

3292  }

3293 

3295  template<class Generator>

3296  void operator()(result_type* output, size_t size)

3297  {

3298  rocrand_status status;

3299  status = rocrand_generate_long_long(m_generator, output, size);

3300  if(status != ROCRAND_STATUS_SUCCESS)

3301  throw rocrand_cpp::error(status);

3302  }

3303 

3305  static constexpr result_type min()

3306  {

3307  return 0;

3308  }

3309 

3311  static constexpr result_type max()

3312  {

3313  return std::numeric_limits<unsigned int>::max();

3314  }

3315 

3317  static constexpr rocrand_rng_type type()

3318  {

3319  return ROCRAND_RNG_PSEUDO_THREEFRY2_64_20;

3320  }

3321 

3322 private:

3323  rocrand_generator m_generator;

3324 

3326  template<class T>

3327  friend class ::rocrand_cpp::uniform_int_distribution;

3328 

3329  template<class T>

3330  friend class ::rocrand_cpp::uniform_real_distribution;

3331 

3332  template<class T>

3333  friend class ::rocrand_cpp::normal_distribution;

3334 

3335  template<class T>

3336  friend class ::rocrand_cpp::lognormal_distribution;

3337 

3338  template<class T>

3339  friend class ::rocrand_cpp::poisson_distribution;

3341 };

3342 

3344 template<unsigned long long DefaultSeed>

3345 constexpr typename threefry2x64_20_engine<DefaultSeed>::seed_type

3346  threefry2x64_20_engine<DefaultSeed>::default_seed;

3348 

3353 template<unsigned long long DefaultSeed = 0>

3354 class threefry4x32_20_engine

3355 {

3356 public:

3358  typedef unsigned int result_type;

3360  typedef rocrand_ordering order_type;

3362  typedef unsigned long long offset_type;

3364  typedef unsigned long long seed_type;

3366  static constexpr seed_type default_seed = DefaultSeed;

3367 

3369  threefry4x32_20_engine(seed_type seed_value = DefaultSeed,

3370  offset_type offset_value = 0,

3371  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

3372  {

3373  rocrand_status status;

3374  status = rocrand_create_generator(&m_generator, this->type());

3375  if(status != ROCRAND_STATUS_SUCCESS)

3376  throw rocrand_cpp::error(status);

3377  try

3378  {

3379  if(offset_value > 0)

3380  {

3381  this->offset(offset_value);

3382  }

3383  this->order(order_value);

3384  this->seed(seed_value);

3385  }

3386  catch(...)

3387  {

3388  (void)rocrand_destroy_generator(m_generator);

3389  throw;

3390  }

3391  }

3392 

3394  explicit threefry4x32_20_engine(rocrand_generator& generator) : m_generator(generator)

3395  {

3396  if(generator == NULL)

3397  {

3398  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

3399  }

3400  generator = NULL;

3401  }

3402 

3403  threefry4x32_20_engine(const threefry4x32_20_engine&) = delete;

3404 

3405  threefry4x32_20_engine& operator=(const threefry4x32_20_engine&) = delete;

3406 

3408  threefry4x32_20_engine(threefry4x32_20_engine&& rhs) noexcept : m_generator(rhs.m_generator)

3409  {

3410  rhs.m_generator = nullptr;

3411  }

3412 

3414  threefry4x32_20_engine& operator=(threefry4x32_20_engine&& rhs) noexcept

3415  {

3416  rocrand_status status = rocrand_destroy_generator(m_generator);

3417  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

3418  (void)status;

3419 

3420  m_generator = rhs.m_generator;

3421  rhs.m_generator = nullptr;

3422  return *this;

3423  }

3424 

3426  ~threefry4x32_20_engine() noexcept(false)

3427  {

3428  rocrand_status status = rocrand_destroy_generator(m_generator);

3429  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

3430  throw rocrand_cpp::error(status);

3431  }

3432 

3434  void stream(hipStream_t value)

3435  {

3436  rocrand_status status = rocrand_set_stream(m_generator, value);

3437  if(status != ROCRAND_STATUS_SUCCESS)

3438  throw rocrand_cpp::error(status);

3439  }

3440 

3442  void order(order_type value)

3443  {

3444  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

3445  if(status != ROCRAND_STATUS_SUCCESS)

3446  throw rocrand_cpp::error(status);

3447  }

3448 

3450  void offset(offset_type value)

3451  {

3452  rocrand_status status = rocrand_set_offset(this->m_generator, value);

3453  if(status != ROCRAND_STATUS_SUCCESS)

3454  throw rocrand_cpp::error(status);

3455  }

3456 

3458  void seed(seed_type value)

3459  {

3460  rocrand_status status = rocrand_set_seed(this->m_generator, value);

3461  if(status != ROCRAND_STATUS_SUCCESS)

3462  throw rocrand_cpp::error(status);

3463  }

3464 

3466  template<class Generator>

3467  void operator()(result_type* output, size_t size)

3468  {

3469  rocrand_status status;

3470  status = rocrand_generate(m_generator, output, size);

3471  if(status != ROCRAND_STATUS_SUCCESS)

3472  throw rocrand_cpp::error(status);

3473  }

3474 

3476  static constexpr result_type min()

3477  {

3478  return 0;

3479  }

3480 

3482  static constexpr result_type max()

3483  {

3484  return std::numeric_limits<unsigned int>::max();

3485  }

3486 

3488  static constexpr rocrand_rng_type type()

3489  {

3490  return ROCRAND_RNG_PSEUDO_THREEFRY4_32_20;

3491  }

3492 

3493 private:

3494  rocrand_generator m_generator;

3495 

3497  template<class T>

3498  friend class ::rocrand_cpp::uniform_int_distribution;

3499 

3500  template<class T>

3501  friend class ::rocrand_cpp::uniform_real_distribution;

3502 

3503  template<class T>

3504  friend class ::rocrand_cpp::normal_distribution;

3505 

3506  template<class T>

3507  friend class ::rocrand_cpp::lognormal_distribution;

3508 

3509  template<class T>

3510  friend class ::rocrand_cpp::poisson_distribution;

3512 };

3513 

3515 template<unsigned long long DefaultSeed>

3516 constexpr typename threefry4x32_20_engine<DefaultSeed>::seed_type

3517  threefry4x32_20_engine<DefaultSeed>::default_seed;

3519 

3524 template<unsigned long long DefaultSeed = 0>

3525 class threefry4x64_20_engine

3526 {

3527 public:

3529  typedef unsigned long long result_type;

3531  typedef rocrand_ordering order_type;

3533  typedef unsigned long long offset_type;

3535  typedef unsigned long long seed_type;

3537  static constexpr seed_type default_seed = DefaultSeed;

3538 

3540  threefry4x64_20_engine(seed_type seed_value = DefaultSeed,

3541  offset_type offset_value = 0,

3542  order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)

3543  {

3544  rocrand_status status;

3545  status = rocrand_create_generator(&m_generator, this->type());

3546  if(status != ROCRAND_STATUS_SUCCESS)

3547  throw rocrand_cpp::error(status);

3548  try

3549  {

3550  if(offset_value > 0)

3551  {

3552  this->offset(offset_value);

3553  }

3554  this->order(order_value);

3555  this->seed(seed_value);

3556  }

3557  catch(...)

3558  {

3559  (void)rocrand_destroy_generator(m_generator);

3560  throw;

3561  }

3562  }

3563 

3565  explicit threefry4x64_20_engine(rocrand_generator& generator) : m_generator(generator)

3566  {

3567  if(generator == NULL)

3568  {

3569  throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);

3570  }

3571  generator = NULL;

3572  }

3573 

3574  threefry4x64_20_engine(const threefry4x64_20_engine&) = delete;

3575 

3576  threefry4x64_20_engine& operator=(const threefry4x64_20_engine&) = delete;

3577 

3579  threefry4x64_20_engine(threefry4x64_20_engine&& rhs) noexcept : m_generator(rhs.m_generator)

3580  {

3581  rhs.m_generator = nullptr;

3582  }

3583 

3585  threefry4x64_20_engine& operator=(threefry4x64_20_engine&& rhs) noexcept

3586  {

3587  rocrand_status status = rocrand_destroy_generator(m_generator);

3588  assert(status == ROCRAND_STATUS_SUCCESS || status == ROCRAND_STATUS_NOT_CREATED);

3589  (void)status;

3590 

3591  m_generator = rhs.m_generator;

3592  rhs.m_generator = nullptr;

3593  return *this;

3594  }

3595 

3597  ~threefry4x64_20_engine() noexcept(false)

3598  {

3599  rocrand_status status = rocrand_destroy_generator(m_generator);

3600  if(status != ROCRAND_STATUS_SUCCESS && status != ROCRAND_STATUS_NOT_CREATED)

3601  throw rocrand_cpp::error(status);

3602  }

3603 

3605  void stream(hipStream_t value)

3606  {

3607  rocrand_status status = rocrand_set_stream(m_generator, value);

3608  if(status != ROCRAND_STATUS_SUCCESS)

3609  throw rocrand_cpp::error(status);

3610  }

3611 

3613  void order(order_type value)

3614  {

3615  rocrand_status status = rocrand_set_ordering(this->m_generator, value);

3616  if(status != ROCRAND_STATUS_SUCCESS)

3617  throw rocrand_cpp::error(status);

3618  }

3619 

3621  void offset(offset_type value)

3622  {

3623  rocrand_status status = rocrand_set_offset(this->m_generator, value);

3624  if(status != ROCRAND_STATUS_SUCCESS)

3625  throw rocrand_cpp::error(status);

3626  }

3627 

3629  void seed(seed_type value)

3630  {

3631  rocrand_status status = rocrand_set_seed(this->m_generator, value);

3632  if(status != ROCRAND_STATUS_SUCCESS)

3633  throw rocrand_cpp::error(status);

3634  }

3635 

3637  template<class Generator>

3638  void operator()(result_type* output, size_t size)

3639  {

3640  rocrand_status status;

3641  status = rocrand_generate_long_long(m_generator, output, size);

3642  if(status != ROCRAND_STATUS_SUCCESS)

3643  throw rocrand_cpp::error(status);

3644  }

3645 

3647  static constexpr result_type min()

3648  {

3649  return 0;

3650  }

3651 

3653  static constexpr result_type max()

3654  {

3655  return std::numeric_limits<unsigned int>::max();

3656  }

3657 

3659  static constexpr rocrand_rng_type type()

3660  {

3661  return ROCRAND_RNG_PSEUDO_THREEFRY4_64_20;

3662  }

3663 

3664 private:

3665  rocrand_generator m_generator;

3666 

3668  template<class T>

3669  friend class ::rocrand_cpp::uniform_int_distribution;

3670 

3671  template<class T>

3672  friend class ::rocrand_cpp::uniform_real_distribution;

3673 

3674  template<class T>

3675  friend class ::rocrand_cpp::normal_distribution;

3676 

3677  template<class T>

3678  friend class ::rocrand_cpp::lognormal_distribution;

3679 

3680  template<class T>

3681  friend class ::rocrand_cpp::poisson_distribution;

3683 };

3684 

3686 template<unsigned long long DefaultSeed>

3687 constexpr typename threefry4x64_20_engine<DefaultSeed>::seed_type

3688  threefry4x64_20_engine<DefaultSeed>::default_seed;

3690 

3693 typedef philox4x32_10_engine<> philox4x32_10;

3696 typedef xorwow_engine<> xorwow;

3699 typedef mrg31k3p_engine<> mrg31k3p;

3702 typedef mrg32k3a_engine<> mrg32k3a;

3705 typedef mtgp32_engine<> mtgp32;

3709 typedef lfsr113_engine<> lfsr113;

3712 typedef mt19937_engine<> mt19937;

3715 typedef threefry2x32_20_engine<> threefry2x32;

3718 typedef threefry2x64_20_engine<> threefry2x64;

3721 typedef threefry4x32_20_engine<> threefry4x32;

3724 typedef threefry4x64_20_engine<> threefry4x64;

3727 typedef sobol32_engine<> sobol32;

3730 typedef scrambled_sobol32_engine<> scrambled_sobol32;

3733 typedef sobol64_engine<> sobol64;

3736 typedef scrambled_sobol64_engine<> scrambled_sobol64;

3737 

3740 typedef xorwow default_random_engine;

3741 

3769 typedef std::random_device random_device;

3770 

3773 inline int version()

3774 {

3775  int x;

3776  rocrand_status status = rocrand_get_version(&x);

3777  if(status != ROCRAND_STATUS_SUCCESS)

3778  {

3779  throw rocrand_cpp::error(status);

3780  }

3781  return x;

3782 }

3783 

3785 

3786 } // end namespace rocrand_cpp

3787 

3788 #endif // #if __cplusplus >= 201103L

3789 #endif // ROCRAND_HPP_

rocrand_cpp::error

A run-time rocRAND error.

Definition: rocrand.hpp:52

rocrand_cpp::error::error_code

error_type error_code() const noexcept

Returns the numeric error code.

Definition: rocrand.hpp:67

rocrand_cpp::error::error_string

std::string error_string() const noexcept

Returns a string description of the error.

Definition: rocrand.hpp:73

rocrand_cpp::error::operator!=

friend bool operator!=(const error &l, const error &r)

Compares two error objects for inequality.

Definition: rocrand.hpp:131

rocrand_cpp::error::to_string

static std::string to_string(error_type error)

Definition: rocrand.hpp:90

rocrand_cpp::error::what

const char * what() const noexcept override

Returns a C-string description of the error.

Definition: rocrand.hpp:79

rocrand_cpp::error::error

error(error_type error) noexcept

Definition: rocrand.hpp:60

rocrand_cpp::error::error_type

rocrand_status error_type

rocRAND error code type

Definition: rocrand.hpp:55

rocrand_cpp::error::operator==

friend bool operator==(const error &l, const error &r)

Compares two error objects for equality.

Definition: rocrand.hpp:124

rocrand_cpp::lfsr113_engine

Random number engine based on the LFSR113 algorithm.

Definition: rocrand.hpp:1842

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:1922

rocrand_cpp::lfsr113_engine::operator()

void operator()(result_type *output, size_t size)

Fills output with uniformly distributed random integer values.

Definition: rocrand.hpp:1975

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:1916

rocrand_cpp::lfsr113_engine::seed_type

uint4 seed_type

Definition: rocrand.hpp:1849

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:1996

rocrand_cpp::lfsr113_engine::seed

void seed(unsigned long long value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:1958

rocrand_cpp::lfsr113_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:1966

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:1882

rocrand_cpp::lfsr113_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:1852

rocrand_cpp::lfsr113_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:1845

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:1862

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:1990

rocrand_cpp::lfsr113_engine::lfsr113_engine

lfsr113_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:1902

rocrand_cpp::lfsr113_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:1942

rocrand_cpp::lfsr113_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:1950

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:1984

rocrand_cpp::lfsr113_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:1847

rocrand_cpp::lfsr113_engine::~lfsr113_engine

~lfsr113_engine() noexcept(false)

Definition: rocrand.hpp:1934

rocrand_cpp::lognormal_distribution::param_type

The type of the distribution parameter set.

Definition: rocrand.hpp:572

rocrand_cpp::lognormal_distribution::param_type::m

RealType m() const

Returns the deviation distribution parameter.

Definition: rocrand.hpp:595

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:581

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:615

rocrand_cpp::lognormal_distribution::param_type::s

RealType s() const

Returns the deviation distribution parameter.

Definition: rocrand.hpp:603

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:609

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:557

rocrand_cpp::lognormal_distribution::param

void param(const param_type &params)

Sets the distribution parameter object.

Definition: rocrand.hpp:667

rocrand_cpp::lognormal_distribution::result_type

RealType result_type

See description for RealType template parameter.

Definition: rocrand.hpp:563

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:714

rocrand_cpp::lognormal_distribution::reset

static void reset()

Resets distribution's internal state if there is any.

Definition: rocrand.hpp:640

rocrand_cpp::lognormal_distribution::min

static constexpr RealType min()

Returns the smallest possible value that can be generated.

Definition: rocrand.hpp:673

rocrand_cpp::lognormal_distribution::m

RealType m() const

Returns the mean distribution parameter.

Definition: rocrand.hpp:647

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:704

rocrand_cpp::lognormal_distribution::lognormal_distribution

lognormal_distribution(RealType m=0.0, RealType s=1.0)

Constructs a new distribution object.

Definition: rocrand.hpp:627

rocrand_cpp::lognormal_distribution::max

static RealType max()

Returns the largest possible value that can be generated.

Definition: rocrand.hpp:679

rocrand_cpp::lognormal_distribution::s

RealType s() const

Returns the standard deviation distribution parameter.

Definition: rocrand.hpp:655

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:722

rocrand_cpp::lognormal_distribution::lognormal_distribution

lognormal_distribution(const param_type &params)

Constructs a new distribution object.

Definition: rocrand.hpp:634

rocrand_cpp::lognormal_distribution::param

param_type param() const

Returns the distribution parameter object.

Definition: rocrand.hpp:661

rocrand_cpp::mrg31k3p_engine

Pseudorandom number engine based MRG31k3p CMRG.

Definition: rocrand.hpp:1337

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:1390

rocrand_cpp::mrg31k3p_engine::operator()

void operator()(result_type *output, size_t size)

Fills output with uniformly distributed random integer values.

Definition: rocrand.hpp:1449

rocrand_cpp::mrg31k3p_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:1432

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:1396

rocrand_cpp::mrg31k3p_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:1342

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:1351

rocrand_cpp::mrg31k3p_engine::seed_type

unsigned long long seed_type

Definition: rocrand.hpp:1346

rocrand_cpp::mrg31k3p_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:1344

rocrand_cpp::mrg31k3p_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:1340

rocrand_cpp::mrg31k3p_engine::~mrg31k3p_engine

~mrg31k3p_engine() noexcept(false)

Definition: rocrand.hpp:1408

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:1458

rocrand_cpp::mrg31k3p_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:1424

rocrand_cpp::mrg31k3p_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:1348

rocrand_cpp::mrg31k3p_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:1416

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:1464

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:1470

rocrand_cpp::mrg31k3p_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:1440

rocrand_cpp::mrg31k3p_engine::mrg31k3p_engine

mrg31k3p_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:1376

rocrand_cpp::mrg32k3a_engine

Pseudorandom number engine based MRG32k3a CMRG.

Definition: rocrand.hpp:1509

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:1626

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:1562

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:1638

rocrand_cpp::mrg32k3a_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:1603

rocrand_cpp::mrg32k3a_engine::seed_type

unsigned long long seed_type

Definition: rocrand.hpp:1518

rocrand_cpp::mrg32k3a_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:1516

rocrand_cpp::mrg32k3a_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:1514

rocrand_cpp::mrg32k3a_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:1512

rocrand_cpp::mrg32k3a_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:1610

rocrand_cpp::mrg32k3a_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:1595

rocrand_cpp::mrg32k3a_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:1520

rocrand_cpp::mrg32k3a_engine::~mrg32k3a_engine

~mrg32k3a_engine() noexcept(false)

Definition: rocrand.hpp:1580

rocrand_cpp::mrg32k3a_engine::mrg32k3a_engine

mrg32k3a_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:1547

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:1632

rocrand_cpp::mrg32k3a_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:1588

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:1568

rocrand_cpp::mrg32k3a_engine::operator()

void operator()(result_type *output, size_t size)

Fills output with uniformly distributed random integer values.

Definition: rocrand.hpp:1618

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:1523

rocrand_cpp::mt19937_engine

Random number engine based on the Mersenne Twister algorithm.

Definition: rocrand.hpp:2039

rocrand_cpp::mt19937_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:2126

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:2098

rocrand_cpp::mt19937_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:2044

rocrand_cpp::mt19937_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:2134

rocrand_cpp::mt19937_engine::~mt19937_engine

~mt19937_engine() noexcept(false)

Definition: rocrand.hpp:2110

rocrand_cpp::mt19937_engine::seed_type

unsigned long long seed_type

Definition: rocrand.hpp:2046

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:2058

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:2152

rocrand_cpp::mt19937_engine::operator()

void operator()(result_type *output, size_t size)

Fills output with uniformly distributed random integer values.

Definition: rocrand.hpp:2143

rocrand_cpp::mt19937_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:2118

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:2158

rocrand_cpp::mt19937_engine::mt19937_engine

mt19937_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:2078

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:2092

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:2164

rocrand_cpp::mt19937_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:2048

rocrand_cpp::mt19937_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:2042

rocrand_cpp::mtgp32_engine

Random number engine based on the Mersenne Twister for Graphic Processors algorithm.

Definition: rocrand.hpp:1677

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:1795

rocrand_cpp::mtgp32_engine::~mtgp32_engine

~mtgp32_engine() noexcept(false)

Definition: rocrand.hpp:1750

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:1789

rocrand_cpp::mtgp32_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:1773

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:1738

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:1801

rocrand_cpp::mtgp32_engine::seed_type

unsigned long long seed_type

Definition: rocrand.hpp:1686

rocrand_cpp::mtgp32_engine::mtgp32_engine

mtgp32_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:1717

rocrand_cpp::mtgp32_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:1758

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:1698

rocrand_cpp::mtgp32_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:1765

rocrand_cpp::mtgp32_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:1684

rocrand_cpp::mtgp32_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:1688

rocrand_cpp::mtgp32_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:1680

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:1732

rocrand_cpp::mtgp32_engine::operator()

void operator()(result_type *output, size_t size)

Fills output with uniformly distributed random integer values.

Definition: rocrand.hpp:1781

rocrand_cpp::mtgp32_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:1682

rocrand_cpp::normal_distribution::param_type

The type of the distribution parameter set.

Definition: rocrand.hpp:368

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:391

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:377

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:405

rocrand_cpp::normal_distribution::param_type::stddev

RealType stddev() const

Returns the standard deviation distribution parameter.

Definition: rocrand.hpp:399

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:411

rocrand_cpp::normal_distribution

Produces random numbers according to a normal distribution.

Definition: rocrand.hpp:353

rocrand_cpp::normal_distribution::max

static constexpr RealType max()

Returns the largest possible value that can be generated.

Definition: rocrand.hpp:463

rocrand_cpp::normal_distribution::normal_distribution

normal_distribution(const param_type &params)

Constructs a new distribution object.

Definition: rocrand.hpp:430

rocrand_cpp::normal_distribution::min

static constexpr RealType min()

Returns the smallest possible value that can be generated.

Definition: rocrand.hpp:457

rocrand_cpp::normal_distribution::param

void param(const param_type &params)

Sets the distribution parameter object.

Definition: rocrand.hpp:475

rocrand_cpp::normal_distribution::reset

static void reset()

Resets distribution's internal state if there is any.

Definition: rocrand.hpp:436

rocrand_cpp::normal_distribution::param

param_type param() const

Returns the distribution parameter object.

Definition: rocrand.hpp:469

rocrand_cpp::normal_distribution::mean

RealType mean() const

Returns the mean distribution parameter.

Definition: rocrand.hpp:443

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:499

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:509

rocrand_cpp::normal_distribution::result_type

RealType result_type

See description for RealType template parameter.

Definition: rocrand.hpp:359

rocrand_cpp::normal_distribution::normal_distribution

normal_distribution(RealType mean=0.0, RealType stddev=1.0)

Constructs a new distribution object.

Definition: rocrand.hpp:423

rocrand_cpp::normal_distribution::stddev

RealType stddev() const

Returns the standard deviation distribution parameter.

Definition: rocrand.hpp:451

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:517

rocrand_cpp::philox4x32_10_engine

Pseudorandom number engine based Philox algorithm.

Definition: rocrand.hpp:923

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:1132

rocrand_cpp::philox4x32_10_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:947

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:1007

rocrand_cpp::philox4x32_10_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:1076

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:1018

rocrand_cpp::philox4x32_10_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:940

rocrand_cpp::philox4x32_10_engine::philox4x32_10_engine

philox4x32_10_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:987

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:1126

rocrand_cpp::philox4x32_10_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:1041

rocrand_cpp::philox4x32_10_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:1092

rocrand_cpp::philox4x32_10_engine::seed_type

unsigned long long seed_type

Definition: rocrand.hpp:945

rocrand_cpp::philox4x32_10_engine::~philox4x32_10_engine

~philox4x32_10_engine() noexcept(false)

Definition: rocrand.hpp:1032

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:1112

rocrand_cpp::philox4x32_10_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:1058

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:956

rocrand_cpp::philox4x32_10_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:927

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:1120

rocrand_cpp::philox4x32_10_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:933

rocrand_cpp::poisson_distribution::param_type

The type of the distribution parameter set.

Definition: rocrand.hpp:775

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:798

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:783

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:804

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:810

rocrand_cpp::poisson_distribution

Produces random non-negative integer values distributed according to Poisson distribution.

Definition: rocrand.hpp:762

rocrand_cpp::poisson_distribution::min

static constexpr IntType min()

Returns the smallest possible value that can be generated.

Definition: rocrand.hpp:848

rocrand_cpp::poisson_distribution::mean

double mean() const

Returns the mean distribution parameter.

Definition: rocrand.hpp:842

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:900

rocrand_cpp::poisson_distribution::result_type

IntType result_type

See description for IntType template parameter.

Definition: rocrand.hpp:766

rocrand_cpp::poisson_distribution::param

param_type param()

Returns the distribution parameter object.

Definition: rocrand.hpp:860

rocrand_cpp::poisson_distribution::reset

static void reset()

Resets distribution's internal state if there is any.

Definition: rocrand.hpp:834

rocrand_cpp::poisson_distribution::max

static constexpr IntType max()

Returns the largest possible value that can be generated.

Definition: rocrand.hpp:854

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:890

rocrand_cpp::poisson_distribution::poisson_distribution

poisson_distribution(const param_type &params)

Constructs a new distribution object.

Definition: rocrand.hpp:828

rocrand_cpp::poisson_distribution::poisson_distribution

poisson_distribution(double mean=1.0)

Constructs a new distribution object.

Definition: rocrand.hpp:821

rocrand_cpp::poisson_distribution::param

void param(const param_type &params)

Sets the distribution parameter object.

Definition: rocrand.hpp:866

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:908

rocrand_cpp::scrambled_sobol32_engine

Sobol's scrambled quasi-random sequence generator.

Definition: rocrand.hpp:2403

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:2563

rocrand_cpp::scrambled_sobol32_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:2406

rocrand_cpp::scrambled_sobol32_engine::scrambled_sobol32_engine

scrambled_sobol32_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:2451

rocrand_cpp::scrambled_sobol32_engine::dimensions_num_type

unsigned int dimensions_num_type

Definition: rocrand.hpp:2415

rocrand_cpp::scrambled_sobol32_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:2499

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:2465

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:2426

rocrand_cpp::scrambled_sobol32_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:2408

rocrand_cpp::scrambled_sobol32_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:2491

rocrand_cpp::scrambled_sobol32_engine::~scrambled_sobol32_engine

~scrambled_sobol32_engine() noexcept(false)

Definition: rocrand.hpp:2483

rocrand_cpp::scrambled_sobol32_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:2507

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:2417

rocrand_cpp::scrambled_sobol32_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:2410

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:2471

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:2569

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:2557

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:2548

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:2524

rocrand_cpp::scrambled_sobol64_engine

Sobol's scrambled quasi-random sequence generator.

Definition: rocrand.hpp:2809

rocrand_cpp::scrambled_sobol64_engine::dimensions_num_type

unsigned int dimensions_num_type

Definition: rocrand.hpp:2821

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:2871

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:2832

rocrand_cpp::scrambled_sobol64_engine::offset_type

unsigned long long int offset_type

Definition: rocrand.hpp:2816

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:2963

rocrand_cpp::scrambled_sobol64_engine::result_type

unsigned long long int result_type

Definition: rocrand.hpp:2812

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:2930

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:2969

rocrand_cpp::scrambled_sobol64_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:2913

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:2823

rocrand_cpp::scrambled_sobol64_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:2814

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:2954

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:2877

rocrand_cpp::scrambled_sobol64_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:2905

rocrand_cpp::scrambled_sobol64_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:2897

rocrand_cpp::scrambled_sobol64_engine::~scrambled_sobol64_engine

~scrambled_sobol64_engine() noexcept(false)

Definition: rocrand.hpp:2889

rocrand_cpp::scrambled_sobol64_engine::scrambled_sobol64_engine

scrambled_sobol64_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:2857

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:2975

rocrand_cpp::sobol32_engine

Sobol's quasi-random sequence generator.

Definition: rocrand.hpp:2202

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:2264

rocrand_cpp::sobol32_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:2205

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:2225

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:2352

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:2321

rocrand_cpp::sobol32_engine::sobol32_engine

sobol32_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:2249

rocrand_cpp::sobol32_engine::~sobol32_engine

~sobol32_engine() noexcept(false)

Definition: rocrand.hpp:2282

rocrand_cpp::sobol32_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:2297

rocrand_cpp::sobol32_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:2305

rocrand_cpp::sobol32_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:2209

rocrand_cpp::sobol32_engine::operator()

void operator()(result_type *output, size_t size)

Fills output with uniformly distributed random integer values.

Definition: rocrand.hpp:2344

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:2270

rocrand_cpp::sobol32_engine::dimensions_num_type

unsigned int dimensions_num_type

Definition: rocrand.hpp:2214

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:2364

rocrand_cpp::sobol32_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:2207

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:2216

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:2358

rocrand_cpp::sobol32_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:2290

rocrand_cpp::sobol64_engine

Sobol's quasi-random sequence generator.

Definition: rocrand.hpp:2608

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:2727

rocrand_cpp::sobol64_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:2711

rocrand_cpp::sobol64_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:2703

rocrand_cpp::sobol64_engine::result_type

unsigned long long int result_type

Definition: rocrand.hpp:2611

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:2770

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:2764

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:2631

rocrand_cpp::sobol64_engine::dimensions_num_type

unsigned int dimensions_num_type

Definition: rocrand.hpp:2620

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:2622

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:2676

rocrand_cpp::sobol64_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:2696

rocrand_cpp::sobol64_engine::offset_type

unsigned long long int offset_type

Definition: rocrand.hpp:2613

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:2758

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:2670

rocrand_cpp::sobol64_engine::sobol64_engine

sobol64_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:2655

rocrand_cpp::sobol64_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:2615

rocrand_cpp::sobol64_engine::~sobol64_engine

~sobol64_engine() noexcept(false)

Definition: rocrand.hpp:2688

rocrand_cpp::sobol64_engine::operator()

void operator()(result_type *output, size_t size)

Fills output with uniformly distributed random integer values.

Definition: rocrand.hpp:2750

rocrand_cpp::threefry2x32_20_engine

Pseudorandom number engine based on 2 state ThreeFry.

Definition: rocrand.hpp:3013

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:3134

rocrand_cpp::threefry2x32_20_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:3016

rocrand_cpp::threefry2x32_20_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:3092

rocrand_cpp::threefry2x32_20_engine::threefry2x32_20_engine

threefry2x32_20_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:3052

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:3146

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:3072

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:3027

rocrand_cpp::threefry2x32_20_engine::~threefry2x32_20_engine

~threefry2x32_20_engine() noexcept(false)

Definition: rocrand.hpp:3084

rocrand_cpp::threefry2x32_20_engine::seed_type

unsigned long long seed_type

Definition: rocrand.hpp:3022

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:3125

rocrand_cpp::threefry2x32_20_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:3116

rocrand_cpp::threefry2x32_20_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:3108

rocrand_cpp::threefry2x32_20_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:3024

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:3140

rocrand_cpp::threefry2x32_20_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:3018

rocrand_cpp::threefry2x32_20_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:3020

rocrand_cpp::threefry2x32_20_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:3100

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:3066

rocrand_cpp::threefry2x64_20_engine

Pseudorandom number engine based 2 state ThreeFry.

Definition: rocrand.hpp:3184

rocrand_cpp::threefry2x64_20_engine::seed_type

unsigned long long seed_type

Definition: rocrand.hpp:3193

rocrand_cpp::threefry2x64_20_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:3195

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:3243

rocrand_cpp::threefry2x64_20_engine::result_type

unsigned long long result_type

Definition: rocrand.hpp:3187

rocrand_cpp::threefry2x64_20_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:3287

rocrand_cpp::threefry2x64_20_engine::~threefry2x64_20_engine

~threefry2x64_20_engine() noexcept(false)

Definition: rocrand.hpp:3255

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:3198

rocrand_cpp::threefry2x64_20_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:3189

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:3317

rocrand_cpp::threefry2x64_20_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:3279

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:3237

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:3296

rocrand_cpp::threefry2x64_20_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:3271

rocrand_cpp::threefry2x64_20_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:3191

rocrand_cpp::threefry2x64_20_engine::threefry2x64_20_engine

threefry2x64_20_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:3223

rocrand_cpp::threefry2x64_20_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:3263

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:3305

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:3311

rocrand_cpp::threefry4x32_20_engine

Pseudorandom number engine based on 2 state ThreeFry.

Definition: rocrand.hpp:3355

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:3414

rocrand_cpp::threefry4x32_20_engine::~threefry4x32_20_engine

~threefry4x32_20_engine() noexcept(false)

Definition: rocrand.hpp:3426

rocrand_cpp::threefry4x32_20_engine::seed_type

unsigned long long seed_type

Definition: rocrand.hpp:3364

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:3408

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:3476

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:3369

rocrand_cpp::threefry4x32_20_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:3434

rocrand_cpp::threefry4x32_20_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:3358

rocrand_cpp::threefry4x32_20_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:3450

rocrand_cpp::threefry4x32_20_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:3458

rocrand_cpp::threefry4x32_20_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:3360

rocrand_cpp::threefry4x32_20_engine::threefry4x32_20_engine

threefry4x32_20_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:3394

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:3482

rocrand_cpp::threefry4x32_20_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:3362

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:3467

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:3488

rocrand_cpp::threefry4x32_20_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:3366

rocrand_cpp::threefry4x32_20_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:3442

rocrand_cpp::threefry4x64_20_engine

Pseudorandom number engine based 2 state ThreeFry.

Definition: rocrand.hpp:3526

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:3647

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:3540

rocrand_cpp::threefry4x64_20_engine::threefry4x64_20_engine

threefry4x64_20_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:3565

rocrand_cpp::threefry4x64_20_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:3537

rocrand_cpp::threefry4x64_20_engine::seed_type

unsigned long long seed_type

Definition: rocrand.hpp:3535

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:3585

rocrand_cpp::threefry4x64_20_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:3621

rocrand_cpp::threefry4x64_20_engine::~threefry4x64_20_engine

~threefry4x64_20_engine() noexcept(false)

Definition: rocrand.hpp:3597

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:3659

rocrand_cpp::threefry4x64_20_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:3605

rocrand_cpp::threefry4x64_20_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:3613

rocrand_cpp::threefry4x64_20_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:3533

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:3638

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:3579

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:3653

rocrand_cpp::threefry4x64_20_engine::result_type

unsigned long long result_type

Definition: rocrand.hpp:3529

rocrand_cpp::threefry4x64_20_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:3531

rocrand_cpp::threefry4x64_20_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:3629

rocrand_cpp::uniform_int_distribution

Produces random integer values uniformly distributed on the interval [0, 2^(sizeof(IntType)*8) - 1].

Definition: rocrand.hpp:148

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:215

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:200

rocrand_cpp::uniform_int_distribution::result_type

IntType result_type

See description for IntType template parameter.

Definition: rocrand.hpp:154

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:208

rocrand_cpp::uniform_int_distribution::uniform_int_distribution

uniform_int_distribution()

Default constructor.

Definition: rocrand.hpp:161

rocrand_cpp::uniform_int_distribution::max

static constexpr IntType max()

Returns the largest possible value that can be generated.

Definition: rocrand.hpp:177

rocrand_cpp::uniform_int_distribution::reset

static void reset()

Resets distribution's internal state if there is any.

Definition: rocrand.hpp:166

rocrand_cpp::uniform_int_distribution::min

static constexpr IntType min()

Returns the smallest possible value that can be generated.

Definition: rocrand.hpp:171

rocrand_cpp::uniform_real_distribution

Produces random floating-point values uniformly distributed on the interval (0, 1].

Definition: rocrand.hpp:254

rocrand_cpp::uniform_real_distribution::reset

static void reset()

Resets distribution's internal state if there is any.

Definition: rocrand.hpp:272

rocrand_cpp::uniform_real_distribution::min

static constexpr RealType min()

Returns the smallest possible value that can be generated.

Definition: rocrand.hpp:277

rocrand_cpp::uniform_real_distribution::max

static constexpr RealType max()

Returns the largest possible value that can be generated.

Definition: rocrand.hpp:283

rocrand_cpp::uniform_real_distribution::result_type

RealType result_type

See description for RealType template parameter.

Definition: rocrand.hpp:260

rocrand_cpp::uniform_real_distribution::uniform_real_distribution

uniform_real_distribution()

Default constructor.

Definition: rocrand.hpp:267

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:321

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:306

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:314

rocrand_cpp::xorwow_engine

Pseudorandom number engine based XORWOW algorithm.

Definition: rocrand.hpp:1170

rocrand_cpp::xorwow_engine::order

void order(order_type value)

Sets the order of a random number engine.

Definition: rocrand.hpp:1256

rocrand_cpp::xorwow_engine::stream

void stream(hipStream_t value)

Sets the random number engine's hipStream for kernel launches.

Definition: rocrand.hpp:1249

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:1299

rocrand_cpp::xorwow_engine::seed

void seed(seed_type value)

Sets the seed of the pseudo-random number engine.

Definition: rocrand.hpp:1271

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:1287

rocrand_cpp::xorwow_engine::order_type

rocrand_ordering order_type

Definition: rocrand.hpp:1175

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:1293

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:1223

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:1184

rocrand_cpp::xorwow_engine::xorwow_engine

xorwow_engine(rocrand_generator &generator)

Constructs the pseudo-random number engine.

Definition: rocrand.hpp:1208

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:1229

rocrand_cpp::xorwow_engine::~xorwow_engine

~xorwow_engine() noexcept(false)

Definition: rocrand.hpp:1241

rocrand_cpp::xorwow_engine::operator()

void operator()(result_type *output, size_t size)

Fills output with uniformly distributed random integer values.

Definition: rocrand.hpp:1279

rocrand_cpp::xorwow_engine::offset

void offset(offset_type value)

Sets the offset of a random number engine.

Definition: rocrand.hpp:1264

rocrand_cpp::xorwow_engine::result_type

unsigned int result_type

Definition: rocrand.hpp:1173

rocrand_cpp::xorwow_engine::default_seed

static constexpr seed_type default_seed

The default seed equal to DefaultSeed.

Definition: rocrand.hpp:1181

rocrand_cpp::xorwow_engine::seed_type

unsigned long long seed_type

Definition: rocrand.hpp:1179

rocrand_cpp::xorwow_engine::offset_type

unsigned long long offset_type

Definition: rocrand.hpp:1177

ROCRAND_LFSR113_DEFAULT_SEED_Y

#define ROCRAND_LFSR113_DEFAULT_SEED_Y

Default Y seed for LFSR113 PRNG.

Definition: rocrand_lfsr113.h:37

ROCRAND_LFSR113_DEFAULT_SEED_W

#define ROCRAND_LFSR113_DEFAULT_SEED_W

Default W seed for LFSR113 PRNG.

Definition: rocrand_lfsr113.h:43

ROCRAND_LFSR113_DEFAULT_SEED_Z

#define ROCRAND_LFSR113_DEFAULT_SEED_Z

Default Z seed for LFSR113 PRNG.

Definition: rocrand_lfsr113.h:40

ROCRAND_LFSR113_DEFAULT_SEED_X

#define ROCRAND_LFSR113_DEFAULT_SEED_X

Default X seed for LFSR113 PRNG.

Definition: rocrand_lfsr113.h:34

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:115

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:61

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:84

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:117

ROCRAND_ORDERING_QUASI_DEFAULT

@ ROCRAND_ORDERING_QUASI_DEFAULT

n-dimensional ordering for quasirandom results

Definition: rocrand.h:122

ROCRAND_STATUS_NOT_CREATED

@ ROCRAND_STATUS_NOT_CREATED

Generator was not created using rocrand_create_generator.

Definition: rocrand.h:64

ROCRAND_STATUS_LAUNCH_FAILURE

@ ROCRAND_STATUS_LAUNCH_FAILURE

Kernel launch failure.

Definition: rocrand.h:73

ROCRAND_STATUS_VERSION_MISMATCH

@ ROCRAND_STATUS_VERSION_MISMATCH

Header file and linked library version do not match.

Definition: rocrand.h:63

ROCRAND_STATUS_LENGTH_NOT_MULTIPLE

@ ROCRAND_STATUS_LENGTH_NOT_MULTIPLE

Definition: rocrand.h:68

ROCRAND_STATUS_DOUBLE_PRECISION_REQUIRED

@ ROCRAND_STATUS_DOUBLE_PRECISION_REQUIRED

GPU does not have double precision.

Definition: rocrand.h:72

ROCRAND_STATUS_SUCCESS

@ ROCRAND_STATUS_SUCCESS

No errors.

Definition: rocrand.h:62

ROCRAND_STATUS_INTERNAL_ERROR

@ ROCRAND_STATUS_INTERNAL_ERROR

Internal library error.

Definition: rocrand.h:74

ROCRAND_STATUS_OUT_OF_RANGE

@ ROCRAND_STATUS_OUT_OF_RANGE

Argument out of range.

Definition: rocrand.h:67

ROCRAND_STATUS_ALLOCATION_FAILED

@ ROCRAND_STATUS_ALLOCATION_FAILED

Memory allocation failed during execution.

Definition: rocrand.h:65

ROCRAND_STATUS_TYPE_ERROR

@ ROCRAND_STATUS_TYPE_ERROR

Generator type is wrong.

Definition: rocrand.h:66

ROCRAND_RNG_QUASI_SOBOL64

@ ROCRAND_RNG_QUASI_SOBOL64

Sobol64 quasirandom generator.

Definition: rocrand.h:104

ROCRAND_RNG_PSEUDO_LFSR113

@ ROCRAND_RNG_PSEUDO_LFSR113

LFSR113 pseudorandom generator.

Definition: rocrand.h:91

ROCRAND_RNG_PSEUDO_THREEFRY2_64_20

@ ROCRAND_RNG_PSEUDO_THREEFRY2_64_20

ThreeFry 64 bit state size 2 pseudorandom generator.

Definition: rocrand.h:95

ROCRAND_RNG_PSEUDO_XORWOW

@ ROCRAND_RNG_PSEUDO_XORWOW

XORWOW pseudorandom generator.

Definition: rocrand.h:86

ROCRAND_RNG_PSEUDO_THREEFRY4_32_20

@ ROCRAND_RNG_PSEUDO_THREEFRY4_32_20

ThreeFry 32 bit state size 4 pseudorandom generator.

Definition: rocrand.h:97

ROCRAND_RNG_PSEUDO_MRG31K3P

@ ROCRAND_RNG_PSEUDO_MRG31K3P

MRG31k3p pseudorandom generator.

Definition: rocrand.h:90

ROCRAND_RNG_PSEUDO_MT19937

@ ROCRAND_RNG_PSEUDO_MT19937

Mersenne Twister MT19937 pseudorandom generator.

Definition: rocrand.h:92

ROCRAND_RNG_PSEUDO_PHILOX4_32_10

@ ROCRAND_RNG_PSEUDO_PHILOX4_32_10

PHILOX-4x32-10 pseudorandom generator.

Definition: rocrand.h:89

ROCRAND_RNG_PSEUDO_THREEFRY2_32_20

@ ROCRAND_RNG_PSEUDO_THREEFRY2_32_20

ThreeFry 32 bit state size 2 pseudorandom generator.

Definition: rocrand.h:93

ROCRAND_RNG_PSEUDO_THREEFRY4_64_20

@ ROCRAND_RNG_PSEUDO_THREEFRY4_64_20

ThreeFry 64 bit state size 4 pseudorandom generator.

Definition: rocrand.h:99

ROCRAND_RNG_PSEUDO_MTGP32

@ ROCRAND_RNG_PSEUDO_MTGP32

Mersenne Twister MTGP32 pseudorandom generator.

Definition: rocrand.h:88

ROCRAND_RNG_QUASI_SOBOL32

@ ROCRAND_RNG_QUASI_SOBOL32

Sobol32 quasirandom generator.

Definition: rocrand.h:102

ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL32

@ ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL32

Scrambled Sobol32 quasirandom generator.

Definition: rocrand.h:103

ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL64

@ ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL64

Scrambled Sobol64 quasirandom generator.

Definition: rocrand.h:105

ROCRAND_RNG_PSEUDO_MRG32K3A

@ ROCRAND_RNG_PSEUDO_MRG32K3A

MRG32k3a pseudorandom generator.

Definition: rocrand.h:87

rocrand_cpp::threefry2x32

threefry2x32_20_engine threefry2x32

Typedef of rocrand_cpp::threefry2x32_20_engine PRNG engine with default seed (0).

Definition: rocrand.hpp:3715

rocrand_cpp::mrg31k3p

mrg31k3p_engine mrg31k3p

Typedef of rocrand_cpp::mrg31k3p_engine PRNG engine with default seed (ROCRAND_MRG31K3P_DEFAULT_SEED)...

Definition: rocrand.hpp:3699

rocrand_cpp::version

int version()

Returns rocRAND version.

Definition: rocrand.hpp:3773

rocrand_cpp::mrg32k3a

mrg32k3a_engine mrg32k3a

Typedef of rocrand_cpp::mrg32k3a_engine PRNG engine with default seed (ROCRAND_MRG32K3A_DEFAULT_SEED)...

Definition: rocrand.hpp:3702

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:3736

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:3730

rocrand_cpp::sobol64

sobol64_engine sobol64

Typedef of rocrand_cpp::sobol64_engine QRNG engine with default number of dimensions (1).

Definition: rocrand.hpp:3733

rocrand_cpp::mt19937

mt19937_engine mt19937

Typedef of rocrand_cpp::mt19937_engine PRNG engine with default seed (0).

Definition: rocrand.hpp:3712

rocrand_cpp::sobol32

sobol32_engine sobol32

Typedef of rocrand_cpp::sobol32_engine QRNG engine with default number of dimensions (1).

Definition: rocrand.hpp:3727

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:3709

rocrand_cpp::threefry4x64

threefry4x64_20_engine threefry4x64

Typedef of rocrand_cpp::threefry4x64_20_engine PRNG engine with default seed (0).

Definition: rocrand.hpp:3724

rocrand_cpp::xorwow

xorwow_engine xorwow

Typedef of rocrand_cpp::xorwow_engine PRNG engine with default seed (ROCRAND_XORWOW_DEFAULT_SEED).

Definition: rocrand.hpp:3696

rocrand_cpp::threefry4x32

threefry4x32_20_engine threefry4x32

Typedef of rocrand_cpp::threefry4x32_20_engine PRNG engine with default seed (0).

Definition: rocrand.hpp:3721

rocrand_cpp::threefry2x64

threefry2x64_20_engine threefry2x64

Typedef of rocrand_cpp::threefry2x64_20_engine PRNG engine with default seed (0).

Definition: rocrand.hpp:3718

rocrand_cpp::default_random_engine

xorwow default_random_engine

Default random engine.

Definition: rocrand.hpp:3740

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:3693

rocrand_cpp::mtgp32

mtgp32_engine mtgp32

Typedef of rocrand_cpp::mtgp32_engine PRNG engine with default seed (0).

Definition: rocrand.hpp:3705

rocrand_cpp::random_device

std::random_device random_device

A non-deterministic uniform random number generator.

Definition: rocrand.hpp:3769