pf
rv_samp.h
Go to the documentation of this file.
1 #ifndef RV_SAMP_H
2 #define RV_SAMP_H
3 
4 #include <chrono>
5 #include <Eigen/Dense> //linear algebra stuff
6 #include <random>
7 
8 namespace rvsamp{
9 
10 
12 
20 {
21 public:
22 
26  inline rvsamp_base() :
27  m_rng{static_cast<std::uint32_t>(std::chrono::high_resolution_clock::now().time_since_epoch().count())}
28  {}
29 
30 protected:
31 
33  std::mt19937 m_rng;
34 
35 };
36 
37 
38 
40 
46 template<typename float_t>
48 {
49 
50 public:
51 
52 
57 
58 
64  UnivNormSampler(float_t mu, float_t sigma);
65 
66 
71  void setStdDev(float_t sigma);
72 
73 
78  void setMean(float_t mu);
79 
80 
85  float_t sample();
86 
87 
88 private:
89 
91  std::normal_distribution<float_t> m_z_gen;
92 
94  float_t m_mu;
95 
97  float_t m_sigma;
98 
99 };
100 
101 
102 template<typename float_t>
104  : rvsamp_base()
105  , m_z_gen(0.0, 1.0)
106 {
107  setMean(0.0);
108  setStdDev(1.0);
109 }
110 
111 
112 template<typename float_t>
114  : rvsamp_base()
115  , m_z_gen(0.0, 1.0)
116 {
117  setMean(mu);
118  setStdDev(sigma);
119 }
120 
121 
122 template<typename float_t>
124 {
125  m_mu = mu;
126 }
127 
128 
129 template<typename float_t>
131 {
132  m_sigma = sigma;
133 }
134 
135 
136 template<typename float_t>
138 {
139  return m_mu + m_sigma * m_z_gen(m_rng);
140 }
141 
142 
144 
150 template<typename float_t>
152 {
153 
154 public:
155 
156 
161 
162 
168  UnivLogNormSampler(float_t mu, float_t sigma);
169 
170 
175  void setSigma(float_t sigma);
176 
177 
182  void setMu(float_t mu);
183 
184 
189  float_t sample();
190 
191 
192 private:
193 
195  std::normal_distribution<float_t> m_z_gen;
196 
198  float_t m_mu;
199 
201  float_t m_sigma;
202 
203 };
204 
205 
206 template<typename float_t>
208  : rvsamp_base()
209  , m_z_gen(0.0, 1.0)
210 {
211  setMu(0.0);
212  setSigma(1.0);
213 }
214 
215 
216 template<typename float_t>
218  : rvsamp_base()
219  , m_z_gen(0.0, 1.0)
220 {
221  setMu(mu);
222  setSigma(sigma);
223 }
224 
225 
226 template<typename float_t>
228 {
229  m_mu = mu;
230 }
231 
232 
233 template<typename float_t>
235 {
236  m_sigma = sigma;
237 }
238 
239 
240 template<typename float_t>
242 {
243  return std::exp(m_mu + m_sigma * m_z_gen(m_rng));
244 }
245 
246 
248 
254 template<typename float_t>
256 {
257 
258 public:
259 
260 
265 
266 
271  UnivGammaSampler(float_t alpha, float_t beta);
272 
273 
278  float_t sample();
279 
280 
281 private:
282 
284  std::gamma_distribution<float_t> m_gamma_gen;
285 
287  float_t m_alpha;
288 
290  float_t m_beta;
291 
292 };
293 
294 
295 template<typename float_t>
297  : rvsamp_base()
298  , m_gamma_gen(1.0, 1.0)
299 {
300 }
301 
302 
303 template<typename float_t>
305  : rvsamp_base()
306  , m_gamma_gen(alpha, beta)
307 {
308 }
309 
310 
311 template<typename float_t>
313 {
314  return m_gamma_gen(m_rng);
315 }
316 
317 
319 
325 template<typename float_t>
327 {
328 
329 public:
330 
331 
336 
337 
342  UnivInvGammaSampler(float_t alpha, float_t beta);
343 
344 
349  float_t sample();
350 
351 
352 private:
353 
355  std::gamma_distribution<float_t> m_gamma_gen;
356 
358  float_t m_alpha;
359 
361  float_t m_beta;
362 
363 };
364 
365 
366 template<typename float_t>
368  : rvsamp_base()
369  , m_gamma_gen(1.0, 1.0)
370 {
371 }
372 
373 
374 template<typename float_t>
376  : rvsamp_base()
377  , m_gamma_gen(alpha, beta)
378 {
379 }
380 
381 
382 template<typename float_t>
384 {
385  return 1.0/m_gamma_gen(m_rng);
386 }
387 
388 
390 
400 template<typename float_t>
402 {
403 
404 public:
405 
406 
414  TruncUnivNormSampler(float_t mu, float_t sigma, float_t lower, float_t upper);
415 
416 
421  float_t sample();
422 
423 
424 private:
425 
427  std::normal_distribution<float_t> m_z_gen;
428 
430  float_t m_mu;
431 
433  float_t m_sigma;
434 
436  float_t m_lower;
437 
439  float_t m_upper;
440 };
441 
442 
443 template<typename float_t>
445  float_t sigma,
446  float_t lower,
447  float_t upper)
448  : rvsamp_base()
449  , m_z_gen(0.0, 1.0)
450  , m_mu(mu)
451  , m_sigma(sigma)
452  , m_lower(lower)
453  , m_upper(upper)
454 {
455 }
456 
457 
458 template<typename float_t>
460 {
461  float_t proposal;
462  bool accepted = false;
463  while(!accepted)
464  {
465  proposal = m_mu + m_sigma*m_z_gen(this->m_rng);
466  if((m_lower <= proposal) & (proposal <= m_upper))
467  accepted = true;
468  }
469  return proposal;
470 }
471 
472 
474 
480 template<typename float_t, typename int_t>
482 {
483 
484 public:
485 
486 
490  PoissonSampler();
491 
492 
497  PoissonSampler(float_t lambda);
498 
499 
504  void setLambda(float_t lambda);
505 
506 
511  int_t sample();
512 
513 
514 private:
515 
517  std::poisson_distribution<int_t> m_p_gen;
518 };
519 
520 
521 template<typename float_t, typename int_t>
523  : rvsamp_base(), m_p_gen(float_t(1.0))
524 {
525 }
526 
527 
528 template<typename float_t, typename int_t>
530  : rvsamp_base(), m_p_gen(lambda)
531 {
532 }
533 
534 
535 template<typename float_t, typename int_t>
537 {
538  m_p_gen.param(typename decltype(m_p_gen)::param_type(lambda));
539 }
540 
541 
542 template<typename float_t, typename int_t>
544 {
545  return m_p_gen(m_rng);
546 }
547 
548 
550 
556 template<typename float_t, typename int_t>
557 class BernSampler : public rvsamp_base
558 {
559 
560 public:
561 
562 
566  BernSampler();
567 
568 
573  BernSampler(float_t p);
574 
575 
580  void setP(float_t p);
581 
582 
587  int_t sample();
588 
589 
590 private:
591 
593  std::bernoulli_distribution m_B_gen;
594 
596  float_t m_p;
597 };
598 
599 
600 template<typename float_t, typename int_t>
602  : rvsamp_base(), m_B_gen(.5)
603 {
604 }
605 
606 
607 template<typename float_t, typename int_t>
609  : rvsamp_base(), m_B_gen(p)
610 {
611 }
612 
613 
614 template<typename float_t, typename int_t>
616 {
617  m_p = p;
618 }
619 
620 
621 template<typename float_t, typename int_t>
623 {
624  return (m_B_gen(m_rng)) ? 1 : 0;
625 }
626 
627 
628 
630 
636 template<size_t dim, typename float_t>
637 class MVNSampler : public rvsamp_base
638 {
639 public:
640 
642  using Vec = Eigen::Matrix<float_t,dim,1>;
644  using Mat = Eigen::Matrix<float_t,dim,dim>;
645 
653  MVNSampler();
654 
655 
661  MVNSampler(const Vec &meanVec, const Mat &covMat);
662 
663 
668  void setCovar(const Mat &covMat);
669 
670 
675  void setMean(const Vec &meanVec);
676 
677 
682  auto sample() -> Vec;
683 
684 private:
685 
687  std::normal_distribution<float_t> m_z_gen;
688 
691 
694 
695 };
696 
697 
698 template<size_t dim, typename float_t>
700  : rvsamp_base()
701  , m_z_gen(0.0, 1.0)
702 {
703  setMean(Vec::Zero());
704  setCovar(Mat::Identity());
705 }
706 
707 
708 template<size_t dim, typename float_t>
709 MVNSampler<dim, float_t>::MVNSampler(const Vec &meanVec, const Mat &covMat)
710  : rvsamp_base()
711  , m_z_gen(0.0, 1.0)
712 {
713  setCovar(covMat);
714  setMean(meanVec);
715 }
716 
717 
718 template<size_t dim, typename float_t>
720 {
721  Eigen::SelfAdjointEigenSolver<Mat> eigenSolver(covMat);
722  m_scale_mat = eigenSolver.eigenvectors() * eigenSolver.eigenvalues().cwiseMax(0).cwiseSqrt().asDiagonal();
723 }
724 
725 
726 template<size_t dim, typename float_t>
728 {
729  m_mean = meanVec;
730 }
731 
732 
733 template<size_t dim, typename float_t>
735 {
736  Vec Z;
737  for (size_t i=0; i< dim; ++i)
738  {
739  Z(i) = m_z_gen(this->m_rng);
740  }
741  return m_mean + m_scale_mat * Z;
742 }
743 
744 
745 
747 
753 template<typename float_t>
755 {
756 public:
757 
761  UniformSampler();
762 
763 
769  UniformSampler(float_t lower, float_t upper);
770 
771 
776  float_t sample();
777 
778 private:
779 
781  std::uniform_real_distribution<float_t> m_unif_gen;
782 
783 };
784 
785 
786 template<typename float_t>
788  : rvsamp_base()
789  , m_unif_gen(0.0, 1.0)
790 {
791 }
792 
793 
794 template<typename float_t>
795 UniformSampler<float_t>::UniformSampler(float_t lower, float_t upper)
796  : rvsamp_base()
797  , m_unif_gen(lower, upper)
798 {
799 }
800 
801 
802 template<typename float_t>
804 {
805  return m_unif_gen(m_rng);
806 }
807 
808 
809 
811 
818 template<size_t N, typename float_t>
819 class k_gen : public rvsamp_base
820 {
821 public:
825  k_gen();
826 
827 
833  std::array<unsigned int, N> sample(const std::array<float_t, N> &logWts);
834 };
835 
836 
837 template<size_t N, typename float_t>
839 
840 
841 template<size_t N, typename float_t>
842 std::array<unsigned int, N> k_gen<N, float_t>::sample(const std::array<float_t, N> &logWts)
843 {
844  // these log weights may be very negative. If that's the case, exponentiating them may cause underflow
845  // so we use the "log-exp-sum" trick
846  // actually not quite...we just shift the log-weights because after they're exponentiated
847  // they have the same normalized probabilities
848 
849  // Create the distribution with exponentiated log-weights
850  // subtract the max first to prevent underflow
851  // normalization is taken care of by std::discrete_distribution
852  std::array<float_t, N> w;
853  float_t m = *std::max_element(logWts.begin(), logWts.end());
854  std::transform(logWts.begin(), logWts.end(), w.begin(),
855  [&m](float_t d) -> float_t { return std::exp(d-m); } );
856  std::discrete_distribution<> kGen(w.begin(), w.end());
857 
858  // sample and return ks
859  std::array<unsigned int, N> ks;
860  for(size_t i = 0; i < N; ++i){
861  ks[i] = kGen(this->m_rng);
862  }
863  return ks;
864 }
865 
866 
867 
868 } // namespace rv_samp
869 
870 
871 
872 #endif // RV_SAMP_H
std::normal_distribution< float_t > m_z_gen
makes normal random variates
Definition: rv_samp.h:427
float_t m_beta
sigma
Definition: rv_samp.h:361
A class that performs sampling from a univariate Log-Normal distribution.
Definition: rv_samp.h:151
float_t m_p
the mean
Definition: rv_samp.h:596
A class that performs sampling from a univariate Normal distribution.
Definition: rv_samp.h:47
float_t sample()
Draws a random number.
Definition: rv_samp.h:459
A class that performs sampling from a multivariate normal distribution.
Definition: rv_samp.h:637
float_t sample()
draws a random number.
Definition: rv_samp.h:241
Mat m_scale_mat
covariance matrix
Definition: rv_samp.h:690
float_t m_mu
mu
Definition: rv_samp.h:198
A class that performs sampling from a continuous uniform distribution.
Definition: rv_samp.h:754
void setP(float_t p)
sets the parameter p.
Definition: rv_samp.h:615
MVNSampler()
Default-constructor sets up for multivariate standard Normal random variate generation.
Definition: rv_samp.h:699
float_t m_mu
the mean
Definition: rv_samp.h:430
A class that performs sampling from a univariate Bernoulli distribution.
Definition: rv_samp.h:557
void setCovar(const Mat &covMat)
sets the covariance matrix of the sampler.
Definition: rv_samp.h:719
Eigen::Matrix< float_t, dim, 1 > Vec
Definition: rv_samp.h:642
void setStdDev(float_t sigma)
sets the standard deviation of the sampler.
Definition: rv_samp.h:130
void setMu(float_t mu)
sets the location parameter of the logged random variable.
Definition: rv_samp.h:227
int_t sample()
Draws a random number.
Definition: rv_samp.h:543
rvsamp_base()
The default constructor. This is the only option available. Sets the seed with the clock...
Definition: rv_samp.h:26
A class that performs sampling from a univariate Gamma distribution.
Definition: rv_samp.h:255
std::mt19937 m_rng
prng
Definition: rv_samp.h:33
float_t sample()
Draws a random number.
Definition: rv_samp.h:137
UnivLogNormSampler()
Default-constructor sets up for standard Normal random variate generation.
Definition: rv_samp.h:207
std::gamma_distribution< float_t > m_gamma_gen
makes gamma random variates that we take the reciprocal of
Definition: rv_samp.h:355
int_t sample()
Draws a random number.
Definition: rv_samp.h:622
A class that performs sampling from a truncated univariate Normal distribution.
Definition: rv_samp.h:401
float_t m_sigma
sigma
Definition: rv_samp.h:201
float_t m_upper
the upper bound
Definition: rv_samp.h:439
std::normal_distribution< float_t > m_z_gen
makes normal random variates
Definition: rv_samp.h:91
float_t m_sigma
the standard deviation
Definition: rv_samp.h:433
float_t sample()
draws a random number.
Definition: rv_samp.h:383
UnivNormSampler()
Default-constructor sets up for standard Normal random variate generation.
Definition: rv_samp.h:103
k_gen()
default constructor. only one available.
Definition: rv_samp.h:838
std::uniform_real_distribution< float_t > m_unif_gen
makes uniform random variates
Definition: rv_samp.h:781
A class that performs sampling from a univariate Inverse Gamma distribution.
Definition: rv_samp.h:326
UnivInvGammaSampler()
Default-constructor ...
Definition: rv_samp.h:367
float_t m_mu
the mean
Definition: rv_samp.h:94
float_t sample()
draws a random number.
Definition: rv_samp.h:312
std::bernoulli_distribution m_B_gen
makes normal random variates
Definition: rv_samp.h:593
std::normal_distribution< float_t > m_z_gen
makes normal random variates
Definition: rv_samp.h:195
Vec m_mean
mean vector
Definition: rv_samp.h:693
std::gamma_distribution< float_t > m_gamma_gen
makes gamma random variates
Definition: rv_samp.h:284
auto sample() -> Vec
Draws a random vector.
Definition: rv_samp.h:734
TruncUnivNormSampler(float_t mu, float_t sigma, float_t lower, float_t upper)
The user must supply both mean and std. dev.
Definition: rv_samp.h:444
float_t m_beta
sigma
Definition: rv_samp.h:290
Definition: rv_samp.h:8
void setMean(const Vec &meanVec)
sets the mean vector of the sampler.
Definition: rv_samp.h:727
float_t m_sigma
the standard deviation
Definition: rv_samp.h:97
void setSigma(float_t sigma)
sets the scale parameter of the logged random variable.
Definition: rv_samp.h:234
std::poisson_distribution< int_t > m_p_gen
makes normal random variates
Definition: rv_samp.h:517
A class that performs sampling with replacement (useful for the index sampler in an APF) ...
Definition: rv_samp.h:819
float_t sample()
Draws a sample.
Definition: rv_samp.h:803
A class that performs sampling from a Poisson distribution.
Definition: rv_samp.h:481
UnivGammaSampler()
Default-constructor ...
Definition: rv_samp.h:296
UniformSampler()
The default constructor. Gives a lower bound of 0 and upper bound of 1.
Definition: rv_samp.h:787
float_t m_alpha
mu
Definition: rv_samp.h:358
Base class for all random variable sampler types. Primary benefit is that it sets the seed for you...
Definition: rv_samp.h:19
float_t m_lower
the lower bound
Definition: rv_samp.h:436
std::normal_distribution< float_t > m_z_gen
makes normal random variates
Definition: rv_samp.h:687
Eigen::Matrix< float_t, dim, dim > Mat
Definition: rv_samp.h:644
void setLambda(float_t lambda)
sets the parameter lambda.
Definition: rv_samp.h:536
BernSampler()
Default-constructor sets up for Bernoulli random variate generation with p = .5.
Definition: rv_samp.h:601
PoissonSampler()
Default-constructor sets up for Poisson random variate generation with lambda = 1.
Definition: rv_samp.h:522
void setMean(float_t mu)
sets the mean of the sampler.
Definition: rv_samp.h:123
float_t m_alpha
mu
Definition: rv_samp.h:287