IT++ Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
random.h
Go to the documentation of this file.
1 
29 #ifndef RANDOM_H
30 #define RANDOM_H
31 
32 #include <itpp/base/random_dsfmt.h>
33 #include <itpp/base/operators.h>
34 
35 
36 namespace itpp
37 {
38 
40 
51 
54 
56 void RNG_reset(unsigned int seed);
58 void RNG_reset();
60 void RNG_randomize();
62 void RNG_get_state(ivec &state);
64 void RNG_set_state(const ivec &state);
66 
72 {
73 public:
75  Bernoulli_RNG(double prob) { setup(prob); }
77  Bernoulli_RNG() { p = 0.5; }
79  void setup(double prob) {
80  it_assert(prob >= 0.0 && prob <= 1.0, "The Bernoulli source probability "
81  "must be between 0 and 1");
82  p = prob;
83  }
85  double get_setup() const { return p; }
87  bin operator()() { return sample(); }
89  bvec operator()(int n) { bvec temp(n); sample_vector(n, temp); return temp; }
91  bmat operator()(int h, int w) { bmat temp(h, w); sample_matrix(h, w, temp); return temp; }
93  bin sample() { return RNG.genrand_close_open() < p ? bin(1) : bin(0); }
95  void sample_vector(int size, bvec &out) {
96  out.set_size(size, false);
97  for (int i = 0; i < size; i++) out(i) = sample();
98  }
100  void sample_matrix(int rows, int cols, bmat &out) {
101  out.set_size(rows, cols, false);
102  for (int i = 0; i < rows*cols; i++) out(i) = sample();
103  }
104 protected:
105 private:
107  double p;
109  Random_Generator RNG;
110 };
111 
130 {
131 public:
133  I_Uniform_RNG(int min = 0, int max = 1);
135  void setup(int min, int max);
137  void get_setup(int &min, int &max) const;
139  int operator()() { return sample(); }
141  ivec operator()(int n);
143  imat operator()(int h, int w);
145  int sample() {
146  return floor_i(RNG.genrand_close_open() * (hi - lo + 1)) + lo;
147  }
148 private:
150  int lo;
152  int hi;
154  Random_Generator RNG;
155 };
156 
162 {
163 public:
165  Uniform_RNG(double min = 0, double max = 1.0);
167  void setup(double min, double max);
169  void get_setup(double &min, double &max) const;
171  double operator()() { return (sample() * (hi_bound - lo_bound) + lo_bound); }
173  vec operator()(int n) {
174  vec temp(n);
175  sample_vector(n, temp);
176  temp *= hi_bound - lo_bound;
177  temp += lo_bound;
178  return temp;
179  }
181  mat operator()(int h, int w) {
182  mat temp(h, w);
183  sample_matrix(h, w, temp);
184  temp *= hi_bound - lo_bound;
185  temp += lo_bound;
186  return temp;
187  }
189  double sample() { return RNG.genrand_close_open(); }
191  void sample_vector(int size, vec &out) {
192  out.set_size(size, false);
193  for (int i = 0; i < size; i++) out(i) = sample();
194  }
196  void sample_matrix(int rows, int cols, mat &out) {
197  out.set_size(rows, cols, false);
198  for (int i = 0; i < rows*cols; i++) out(i) = sample();
199  }
200 protected:
201 private:
203  double lo_bound, hi_bound;
205  Random_Generator RNG;
206 };
207 
213 {
214 public:
216  Exponential_RNG(double lambda = 1.0);
218  void setup(double lambda) { l = lambda; }
220  double get_setup() const;
222  double operator()() { return sample(); }
224  vec operator()(int n);
226  mat operator()(int h, int w);
227 private:
228  double sample() { return (-std::log(RNG.genrand_open_close()) / l); }
229  double l;
230  Random_Generator RNG;
231 };
232 
248 {
249 public:
251  Normal_RNG(double meanval, double variance):
252  mean(meanval), sigma(std::sqrt(variance)) {}
254  Normal_RNG(): mean(0.0), sigma(1.0) {}
256  void setup(double meanval, double variance)
257  { mean = meanval; sigma = std::sqrt(variance); }
259  void get_setup(double &meanval, double &variance) const;
261  double operator()() { return (sigma*sample() + mean); }
263  vec operator()(int n) {
264  vec temp(n);
265  sample_vector(n, temp);
266  temp *= sigma;
267  temp += mean;
268  return temp;
269  }
271  mat operator()(int h, int w) {
272  mat temp(h, w);
273  sample_matrix(h, w, temp);
274  temp *= sigma;
275  temp += mean;
276  return temp;
277  }
279  double sample();
280 
282  void sample_vector(int size, vec &out) {
283  out.set_size(size, false);
284  for (int i = 0; i < size; i++) out(i) = sample();
285  }
286 
288  void sample_matrix(int rows, int cols, mat &out) {
289  out.set_size(rows, cols, false);
290  for (int i = 0; i < rows*cols; i++) out(i) = sample();
291  }
292 private:
293  double mean, sigma;
294  static const double ytab[128];
295  static const unsigned int ktab[128];
296  static const double wtab[128];
297  static const double PARAM_R;
298  Random_Generator RNG;
299 };
300 
318 {
319 public:
321  Gamma_RNG(double a = 1.0, double b = 1.0): alpha(a), beta(b) {}
323  void setup(double a, double b) { alpha = a; beta = b; }
325  double operator()() { return sample(); }
327  vec operator()(int n);
329  mat operator()(int r, int c);
331  double sample();
332 private:
333  double alpha;
334  double beta;
335  Random_Generator RNG;
336  Normal_RNG NRNG;
337 };
338 
344 {
345 public:
347  Laplace_RNG(double meanval = 0.0, double variance = 1.0);
349  void setup(double meanval, double variance);
351  void get_setup(double &meanval, double &variance) const;
353  double operator()() { return sample(); }
355  vec operator()(int n);
357  mat operator()(int h, int w);
359  double sample() {
360  double u = RNG.genrand_open_open();
361  double l = sqrt_12var;
362  if (u < 0.5)
363  l *= std::log(2.0 * u);
364  else
365  l *= -std::log(2.0 * (1 - u));
366  return (l + mean);
367  }
368 private:
369  double mean, var, sqrt_12var;
370  Random_Generator RNG;
371 };
372 
378 {
379 public:
381  Complex_Normal_RNG(std::complex<double> mean, double variance):
382  norm_factor(1.0 / std::sqrt(2.0)) {
383  setup(mean, variance);
384  }
386  Complex_Normal_RNG(): m(0.0), sigma(1.0), norm_factor(1.0 / std::sqrt(2.0)) {}
388  void setup(std::complex<double> mean, double variance) {
389  m = mean;
390  sigma = std::sqrt(variance);
391  }
393  void get_setup(std::complex<double> &mean, double &variance) {
394  mean = m;
395  variance = sigma * sigma;
396  }
398  std::complex<double> operator()() { return sigma*sample() + m; }
400  cvec operator()(int n) {
401  cvec temp(n);
402  sample_vector(n, temp);
403  temp *= sigma;
404  temp += m;
405  return temp;
406  }
408  cmat operator()(int h, int w) {
409  cmat temp(h, w);
410  sample_matrix(h, w, temp);
411  temp *= sigma;
412  temp += m;
413  return temp;
414  }
416  std::complex<double> sample() {
417  double a = nRNG.sample() * norm_factor;
418  double b = nRNG.sample() * norm_factor;
419  return std::complex<double>(a, b);
420  }
421 
423  void sample_vector(int size, cvec &out) {
424  out.set_size(size, false);
425  for (int i = 0; i < size; i++) out(i) = sample();
426  }
427 
429  void sample_matrix(int rows, int cols, cmat &out) {
430  out.set_size(rows, cols, false);
431  for (int i = 0; i < rows*cols; i++) out(i) = sample();
432  }
433 
435  Complex_Normal_RNG & operator=(const Complex_Normal_RNG&) { return *this; }
436 
437 private:
438  std::complex<double> m;
439  double sigma;
440  const double norm_factor;
441  Normal_RNG nRNG;
442 };
443 
449 {
450 public:
452  AR1_Normal_RNG(double meanval = 0.0, double variance = 1.0,
453  double rho = 0.0);
455  void setup(double meanval, double variance, double rho);
457  void get_setup(double &meanval, double &variance, double &rho) const;
459  void reset();
461  double operator()() { return sample(); }
463  vec operator()(int n);
465  mat operator()(int h, int w);
466 private:
467  double sample() {
468  mem *= r;
469  if (odd) {
470  r1 = m_2pi * RNG.genrand_open_close();
471  r2 = std::sqrt(factr * std::log(RNG.genrand_open_close()));
472  mem += r2 * std::cos(r1);
473  }
474  else {
475  mem += r2 * std::sin(r1);
476  }
477  odd = !odd;
478  return (mem + mean);
479  }
480  double mem, r, factr, mean, var, r1, r2;
481  bool odd;
482  Random_Generator RNG;
483 };
484 
490 
496 
502 {
503 public:
505  Weibull_RNG(double lambda = 1.0, double beta = 1.0);
507  void setup(double lambda, double beta);
509  void get_setup(double &lambda, double &beta) { lambda = l; beta = b; }
511  double operator()() { return sample(); }
513  vec operator()(int n);
515  mat operator()(int h, int w);
516 private:
517  double sample() {
518  return (std::pow(-std::log(RNG.genrand_open_close()), 1.0 / b) / l);
519  }
520  double l, b;
521  double mean, var;
522  Random_Generator RNG;
523 };
524 
530 {
531 public:
533  Rayleigh_RNG(double sigma = 1.0);
535  void setup(double sigma) { sig = sigma; }
537  double get_setup() { return sig; }
539  double operator()() { return sample(); }
541  vec operator()(int n);
543  mat operator()(int h, int w);
544 private:
545  double sample() {
546  double s1 = nRNG.sample();
547  double s2 = nRNG.sample();
548  // s1 and s2 are N(0,1) and independent
549  return (sig * std::sqrt(s1*s1 + s2*s2));
550  }
551  double sig;
552  Normal_RNG nRNG;
553 };
554 
559 class Rice_RNG
560 {
561 public:
563  Rice_RNG(double sigma = 1.0, double v = 1.0);
565  void setup(double sigma, double v) { sig = sigma; s = v; }
567  void get_setup(double &sigma, double &v) { sigma = sig; v = s; }
569  double operator()() { return sample(); }
571  vec operator()(int n);
573  mat operator()(int h, int w);
574 private:
575  double sample() {
576  double s1 = nRNG.sample() + s;
577  double s2 = nRNG.sample();
578  // s1 and s2 are N(0,1) and independent
579  return (sig * std::sqrt(s1*s1 + s2*s2));
580  }
581  double sig, s;
582  Normal_RNG nRNG;
583 };
584 
587 
589 inline bin randb(void) { Bernoulli_RNG src; return src.sample(); }
591 inline void randb(int size, bvec &out) { Bernoulli_RNG src; src.sample_vector(size, out); }
593 inline bvec randb(int size) { bvec temp; randb(size, temp); return temp; }
595 inline void randb(int rows, int cols, bmat &out) { Bernoulli_RNG src; src.sample_matrix(rows, cols, out); }
597 inline bmat randb(int rows, int cols) { bmat temp; randb(rows, cols, temp); return temp; }
598 
600 inline double randu(void) { Uniform_RNG src; return src.sample(); }
602 inline void randu(int size, vec &out) { Uniform_RNG src; src.sample_vector(size, out); }
604 inline vec randu(int size) { vec temp; randu(size, temp); return temp; }
606 inline void randu(int rows, int cols, mat &out) { Uniform_RNG src; src.sample_matrix(rows, cols, out); }
608 inline mat randu(int rows, int cols) { mat temp; randu(rows, cols, temp); return temp; }
609 
611 inline int randi(int low, int high) { I_Uniform_RNG src; src.setup(low, high); return src(); }
613 inline ivec randi(int size, int low, int high) { I_Uniform_RNG src; src.setup(low, high); return src(size); }
615 inline imat randi(int rows, int cols, int low, int high) { I_Uniform_RNG src; src.setup(low, high); return src(rows, cols); }
616 
618 inline vec randray(int size, double sigma = 1.0) { Rayleigh_RNG src; src.setup(sigma); return src(size); }
619 
621 inline vec randrice(int size, double sigma = 1.0, double s = 1.0) { Rice_RNG src; src.setup(sigma, s); return src(size); }
622 
624 inline vec randexp(int size, double lambda = 1.0) { Exponential_RNG src; src.setup(lambda); return src(size); }
625 
627 inline double randn(void) { Normal_RNG src; return src.sample(); }
629 inline void randn(int size, vec &out) { Normal_RNG src; src.sample_vector(size, out); }
631 inline vec randn(int size) { vec temp; randn(size, temp); return temp; }
633 inline void randn(int rows, int cols, mat &out) { Normal_RNG src; src.sample_matrix(rows, cols, out); }
635 inline mat randn(int rows, int cols) { mat temp; randn(rows, cols, temp); return temp; }
636 
641 inline std::complex<double> randn_c(void) { Complex_Normal_RNG src; return src.sample(); }
643 inline void randn_c(int size, cvec &out) { Complex_Normal_RNG src; src.sample_vector(size, out); }
645 inline cvec randn_c(int size) { cvec temp; randn_c(size, temp); return temp; }
647 inline void randn_c(int rows, int cols, cmat &out) { Complex_Normal_RNG src; src.sample_matrix(rows, cols, out); }
649 inline cmat randn_c(int rows, int cols) { cmat temp; randn_c(rows, cols, temp); return temp; }
650 
652 
653 } // namespace itpp
654 
655 #endif // #ifndef RANDOM_H
SourceForge Logo

Generated on Fri Mar 21 2014 17:14:13 for IT++ by Doxygen 1.8.1.2