13 #ifndef EIGENRAND_DISTS_NORMAL_EXP_H
14 #define EIGENRAND_DISTS_NORMAL_EXP_H
25 template<
typename _Scalar>
28 static_assert(std::is_floating_point<_Scalar>::value,
"normalDist needs floating point types.");
33 using Scalar = _Scalar;
35 template<
typename Rng>
36 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
38 using namespace Eigen::internal;
42 return OptCacheStore::get<_Scalar>();
51 sx = v1 * v1 + v2 * v2;
52 if (sx && sx < 1)
break;
54 _Scalar fx = std::sqrt((_Scalar)-2.0 * std::log(sx) / sx);
55 OptCacheStore::get<_Scalar>() = fx * v2;
59 template<
typename Packet,
typename Rng>
60 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
62 using namespace Eigen::internal;
66 return OptCacheStore::template get<Packet>();
69 Packet u1 = ur.template packetOp<Packet>(rng),
70 u2 = ur.template packetOp<Packet>(rng);
72 u1 = psub(pset1<Packet>(1), u1);
74 auto radius = psqrt(pmul(pset1<Packet>(-2), plog(u1)));
75 auto theta = pmul(pset1<Packet>(2 * constant::pi), u2);
76 Packet sintheta, costheta;
78 psincos(theta, sintheta, costheta);
79 OptCacheStore::template get<Packet>() = pmul(radius, costheta);
80 return pmul(radius, sintheta);
89 template<
typename _Scalar>
92 static_assert(std::is_floating_point<_Scalar>::value,
"normalDist needs floating point types.");
94 _Scalar mean = 0, stdev = 1;
97 using Scalar = _Scalar;
106 : mean{ _mean }, stdev{ _stdev }
116 template<
typename Rng>
117 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
119 using namespace Eigen::internal;
120 return stdnorm(std::forward<Rng>(rng)) * stdev + mean;
123 template<
typename Packet,
typename Rng>
124 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
126 using namespace Eigen::internal;
128 stdnorm.template packetOp<Packet>(std::forward<Rng>(rng)),
130 ), pset1<Packet>(mean));
139 template<
typename _Scalar>
142 static_assert(std::is_floating_point<_Scalar>::value,
"lognormalDist needs floating point types.");
146 using Scalar = _Scalar;
155 : norm{ _mean, _stdev }
165 template<
typename Rng>
166 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
168 using namespace Eigen::internal;
169 return std::exp(norm(std::forward<Rng>(rng)));
172 template<
typename Packet,
typename Rng>
173 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
175 using namespace Eigen::internal;
176 return pexp(norm.template packetOp<Packet>(std::forward<Rng>(rng)));
185 template<
typename _Scalar>
188 static_assert(std::is_floating_point<_Scalar>::value,
"studentT needs floating point types.");
193 using Scalar = _Scalar;
211 template<
typename Rng>
212 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
214 using namespace Eigen::internal;
218 v1 = 2 * ur(rng) - 1;
219 v2 = 2 * ur(rng) - 1;
220 sx = v1 * v1 + v2 * v2;
221 if (sx && sx < 1)
break;
224 _Scalar fx = std::sqrt(n * (std::pow(sx, -2 / n) - 1) / sx);
228 template<
typename Packet,
typename Rng>
229 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
231 using namespace Eigen::internal;
232 Packet u1 = ur.template packetOp<Packet>(rng),
233 u2 = ur.template packetOp<Packet>(rng);
235 u1 = psub(pset1<Packet>(1), u1);
236 auto pn = pset1<Packet>(n);
237 auto radius = psqrt(pmul(pn,
238 psub(pexp(pmul(plog(u1), pset1<Packet>(-2 / n))), pset1<Packet>(1))
240 auto theta = pmul(pset1<Packet>(2 * constant::pi), u2);
243 return pmul(radius, psin(theta));
247 template<
typename>
class GammaGen;
254 template<
typename _Scalar>
258 static_assert(std::is_floating_point<_Scalar>::value,
"expDist needs floating point types.");
263 using Scalar = _Scalar;
281 template<
typename Rng>
282 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
284 using namespace Eigen::internal;
285 return -std::log(1 - ur(std::forward<Rng>(rng))) / lambda;
288 template<
typename Packet,
typename Rng>
289 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
291 using namespace Eigen::internal;
292 return pnegate(pdiv(plog(
293 psub(pset1<Packet>(1), ur.template packetOp<Packet>(std::forward<Rng>(rng)))
294 ), pset1<Packet>(lambda)));
298 template<
typename>
class NegativeBinomialGen;
305 template<
typename _Scalar>
308 template<
typename _Ty>
310 static_assert(std::is_floating_point<_Scalar>::value,
"gammaDist needs floating point types.");
311 int cache_rest_cnt = 0;
313 _Scalar alpha,
beta, px, sqrt;
316 using Scalar = _Scalar;
325 : alpha{ _alpha },
beta{ _beta }
327 px = constant::e / (alpha + constant::e);
328 sqrt = std::sqrt(2 * alpha - 1);
337 template<
typename Rng>
338 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
340 using namespace Eigen::internal;
343 _Scalar ux, vx, xx, qx;
347 vx = expon.ur.nzur_scalar(rng);
351 xx = std::pow(vx, 1 / alpha);
356 xx = 1 - std::log(vx);
357 qx = std::pow(xx, alpha - 1);
360 if (expon.ur(rng) < qx)
368 return beta * expon(rng);
371 if ((count = alpha) == alpha && count < 20)
374 yx = expon.ur.nzur_scalar(rng);
377 yx *= expon.ur.nzur_scalar(rng);
379 return -
beta * std::log(yx);
385 yx = std::tan(constant::pi * expon.ur(rng));
386 xx = sqrt * yx + alpha - 1;
387 if (xx <= 0)
continue;
388 if (expon.ur(rng) <= (1 + yx * yx)
389 * std::exp((alpha - 1) * std::log(xx / (alpha - 1)) - sqrt * yx))
396 template<
typename Packet,
typename Rng>
397 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
399 using namespace Eigen::internal;
400 using RUtils = RandUtils<Packet, Rng>;
401 auto& cm = Rand::detail::CompressMask<
sizeof(Packet)>::get_inst();
408 Packet ux = ru.uniform_real(rng);
409 Packet vx = ru.nonzero_uniform_real(rng);
411 Packet xx = pexp(pmul(pset1<Packet>(1 / alpha), plog(vx)));
412 Packet qx = pexp(pnegate(xx));
414 Packet xx2 = psub(pset1<Packet>(1), plog(vx));
415 Packet qx2 = pexp(pmul(plog(xx2), pset1<Packet>(alpha - 1)));
417 auto c = pcmplt(ux, pset1<Packet>(px));
418 xx = pblendv(c, xx, xx2);
419 qx = pblendv(c, qx, qx2);
421 ux = ru.uniform_real(rng);
422 Packet cands = pmul(pset1<Packet>(
beta), xx);
424 cache_rest_cnt = cm.compress_append(cands, pcmplt(ux, qx),
425 OptCacheStore::template get<Packet>(), cache_rest_cnt, full);
426 if (full)
return cands;
431 return pmul(pset1<Packet>(
beta),
432 expon.template packetOp<Packet>(rng)
436 if ((count = alpha) == alpha && count < 20)
440 yx = ru.nonzero_uniform_real(rng);
443 yx = pmul(yx, ru.nonzero_uniform_real(rng));
445 return pnegate(pmul(pset1<Packet>(
beta), plog(yx)));
451 Packet alpha_1 = pset1<Packet>(alpha - 1);
453 psincos(pmul(pset1<Packet>(constant::pi), ru.uniform_real(rng)), ys, yc);
454 Packet yx = pdiv(ys, yc);
455 Packet xx = padd(pmul(pset1<Packet>(sqrt), yx), alpha_1);
456 auto c = pcmplt(pset1<Packet>(0), xx);
457 Packet ux = ru.uniform_real(rng);
458 Packet ub = pmul(padd(pmul(yx, yx), pset1<Packet>(1)),
460 pmul(alpha_1, plog(pdiv(xx, alpha_1))),
461 pmul(yx, pset1<Packet>(sqrt))
464 c = pand(c, pcmple(ux, ub));
465 Packet cands = pmul(pset1<Packet>(
beta), xx);
467 cache_rest_cnt = cm.compress_append(cands, c,
468 OptCacheStore::template get<Packet>(), cache_rest_cnt, full);
469 if (full)
return cands;
480 template<
typename _Scalar>
483 static_assert(std::is_floating_point<_Scalar>::value,
"weilbullDist needs floating point types.");
485 _Scalar a = 1, b = 1;
488 using Scalar = _Scalar;
507 template<
typename Rng>
508 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
510 using namespace Eigen::internal;
511 return std::pow(-std::log(1 - ur(std::forward<Rng>(rng))), 1 / a) * b;
514 template<
typename Packet,
typename Rng>
515 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
517 using namespace Eigen::internal;
518 return pmul(pexp(pmul(plog(pnegate(plog(
519 psub(pset1<Packet>(1), ur.template packetOp<Packet>(std::forward<Rng>(rng)))
520 ))), pset1<Packet>(1 / a))), pset1<Packet>(b));
529 template<
typename _Scalar>
532 static_assert(std::is_floating_point<_Scalar>::value,
"extremeValueDist needs floating point types.");
534 _Scalar a = 0, b = 1;
537 using Scalar = _Scalar;
556 template<
typename Rng>
557 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
559 using namespace Eigen::internal;
560 return (a - b * std::log(-std::log(ur.nzur_scalar(std::forward<Rng>(rng)))));
563 template<
typename Packet,
typename Rng>
564 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
566 using namespace Eigen::internal;
567 using RUtils = RandUtils<Packet, Rng>;
568 return psub(pset1<Packet>(a),
569 pmul(plog(pnegate(plog(RUtils{}.nonzero_uniform_real(std::forward<Rng>(rng))))), pset1<Packet>(b))
579 template<
typename _Scalar>
582 static_assert(std::is_floating_point<_Scalar>::value,
"chiSquaredDist needs floating point types.");
585 using Scalar = _Scalar;
593 :
gamma{ n * _Scalar(0.5), 2 }
603 template<
typename Rng>
604 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
609 template<
typename Packet,
typename Rng>
610 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
612 return gamma.template packetOp<Packet>(rng);
621 template<
typename _Scalar>
624 static_assert(std::is_floating_point<_Scalar>::value,
"cauchyDist needs floating point types.");
626 _Scalar a = 0, b = 1;
629 using Scalar = _Scalar;
648 template<
typename Rng>
649 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
651 using namespace Eigen::internal;
652 return a + b * std::tan(constant::pi * (ur(std::forward<Rng>(rng)) - 0.5));
655 template<
typename Packet,
typename Rng>
656 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
658 using namespace Eigen::internal;
660 psincos(pmul(pset1<Packet>(constant::pi),
661 psub(ur.template packetOp<Packet>(std::forward<Rng>(rng)), pset1<Packet>(0.5))
663 return padd(pset1<Packet>(a),
664 pmul(pset1<Packet>(b), pdiv(s, c))
669 template<
typename>
class FisherFGen;
676 template<
typename _Scalar>
680 static_assert(std::is_floating_point<_Scalar>::value,
"betaDist needs floating point types.");
681 int cache_rest_cnt = 0;
687 using Scalar = _Scalar;
706 template<
typename Rng>
707 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
709 using namespace Eigen::internal;
715 p1 = std::pow(ur(rng), 1 / a);
716 p2 = std::pow(ur(rng), 1 / b);
724 _Scalar p1 = gd1(rng), p2 = gd2(rng);
725 return p1 / (p1 + p2);
729 template<
typename Packet,
typename Rng>
730 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
732 using namespace Eigen::internal;
735 auto& cm = Rand::detail::CompressMask<
sizeof(Packet)>::get_inst();
739 p1 = pexp(pmul(plog(ur.template packetOp<Packet>(rng)), pset1<Packet>(1 / a)));
740 p2 = pexp(pmul(plog(ur.template packetOp<Packet>(rng)), pset1<Packet>(1 / b)));
742 Packet cands = pdiv(p1, x);
744 cache_rest_cnt = cm.compress_append(cands, pcmple(x, pset1<Packet>(1)),
745 OptCacheStore::template get<Packet>(), cache_rest_cnt, full);
746 if (full)
return cands;
751 auto p1 = gd1.template packetOp<Packet>(rng),
752 p2 = gd2.template packetOp<Packet>(rng);
753 return pdiv(p1, padd(p1, p2));
763 template<
typename _Scalar>
766 static_assert(std::is_floating_point<_Scalar>::value,
"fisherF needs floating point types.");
769 using Scalar = _Scalar;
777 :
beta{ m * _Scalar(0.5), n * _Scalar(0.5) }
787 template<
typename Rng>
788 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
790 using namespace Eigen::internal;
791 auto x =
beta(std::forward<Rng>(rng));
792 return beta.b /
beta.a * x / (1 - x);
795 template<
typename Packet,
typename Rng>
796 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
798 using namespace Eigen::internal;
799 auto x =
beta.template packetOp<Packet>(std::forward<Rng>(rng));
800 return pdiv(pmul(pset1<Packet>(
beta.b /
beta.a), x), psub(pset1<Packet>(1), x));
805 template<
typename Derived,
typename Urng>
806 using BetaType = CwiseNullaryOp<internal::scalar_rng_adaptor<BetaGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
821 template<
typename Derived,
typename Urng>
822 inline const BetaType<Derived, Urng>
823 beta(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar a = 1,
typename Derived::Scalar b = 1)
842 template<
typename Derived,
typename Urng>
843 inline const BetaType<Derived, Urng>
844 betaLike(Derived& o, Urng&& urng,
typename Derived::Scalar a = 1,
typename Derived::Scalar b = 1)
851 template<
typename Derived,
typename Urng>
852 using CauchyType = CwiseNullaryOp<internal::scalar_rng_adaptor<CauchyGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
868 template<
typename Derived,
typename Urng>
869 inline const CauchyType<Derived, Urng>
870 cauchy(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar a = 0,
typename Derived::Scalar b = 1)
890 template<
typename Derived,
typename Urng>
891 inline const CauchyType<Derived, Urng>
892 cauchyLike(Derived& o, Urng&& urng,
typename Derived::Scalar a = 0,
typename Derived::Scalar b = 1)
899 template<
typename Derived,
typename Urng>
900 using NormalType = CwiseNullaryOp<internal::scalar_rng_adaptor<StdNormalGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
914 template<
typename Derived,
typename Urng>
915 inline const NormalType<Derived, Urng>
916 normal(Index rows, Index cols, Urng&& urng)
919 rows, cols, { std::forward<Urng>(urng) }
934 template<
typename Derived,
typename Urng>
935 inline const NormalType<Derived, Urng>
939 o.rows(), o.cols(), { std::forward<Urng>(urng) }
943 template<
typename Derived,
typename Urng>
944 using Normal2Type = CwiseNullaryOp<internal::scalar_rng_adaptor<NormalGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
960 template<
typename Derived,
typename Urng>
961 inline const Normal2Type<Derived, Urng>
962 normal(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar mean,
typename Derived::Scalar stdev = 1)
982 template<
typename Derived,
typename Urng>
983 inline const Normal2Type<Derived, Urng>
984 normalLike(Derived& o, Urng&& urng,
typename Derived::Scalar mean,
typename Derived::Scalar stdev = 1)
991 template<
typename Derived,
typename Urng>
992 using LognormalType = CwiseNullaryOp<internal::scalar_rng_adaptor<LognormalGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1008 template<
typename Derived,
typename Urng>
1009 inline const LognormalType<Derived, Urng>
1010 lognormal(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar mean = 0,
typename Derived::Scalar stdev = 1)
1030 template<
typename Derived,
typename Urng>
1031 inline const LognormalType<Derived, Urng>
1032 lognormalLike(Derived& o, Urng&& urng,
typename Derived::Scalar mean = 0,
typename Derived::Scalar stdev = 1)
1039 template<
typename Derived,
typename Urng>
1040 using StudentTType = CwiseNullaryOp<internal::scalar_rng_adaptor<StudentTGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1055 template<
typename Derived,
typename Urng>
1056 inline const StudentTType<Derived, Urng>
1057 studentT(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar n = 1)
1076 template<
typename Derived,
typename Urng>
1077 inline const StudentTType<Derived, Urng>
1085 template<
typename Derived,
typename Urng>
1086 using ExponentialType = CwiseNullaryOp<internal::scalar_rng_adaptor<ExponentialGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1101 template<
typename Derived,
typename Urng>
1102 inline const ExponentialType<Derived, Urng>
1103 exponential(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar lambda = 1)
1122 template<
typename Derived,
typename Urng>
1123 inline const ExponentialType<Derived, Urng>
1131 template<
typename Derived,
typename Urng>
1132 using GammaType = CwiseNullaryOp<internal::scalar_rng_adaptor<GammaGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1148 template<
typename Derived,
typename Urng>
1149 inline const GammaType<Derived, Urng>
1150 gamma(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar alpha = 1,
typename Derived::Scalar
beta = 1)
1170 template<
typename Derived,
typename Urng>
1171 inline const GammaType<Derived, Urng>
1172 gammaLike(Derived& o, Urng&& urng,
typename Derived::Scalar alpha = 1,
typename Derived::Scalar
beta = 1)
1179 template<
typename Derived,
typename Urng>
1180 using WeibullType = CwiseNullaryOp<internal::scalar_rng_adaptor<WeibullGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1196 template<
typename Derived,
typename Urng>
1197 inline const WeibullType<Derived, Urng>
1198 weibull(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar a = 1,
typename Derived::Scalar b = 1)
1218 template<
typename Derived,
typename Urng>
1219 inline const WeibullType<Derived, Urng>
1220 weibullLike(Derived& o, Urng&& urng,
typename Derived::Scalar a = 1,
typename Derived::Scalar b = 1)
1227 template<
typename Derived,
typename Urng>
1228 using ExtremeValueType = CwiseNullaryOp<internal::scalar_rng_adaptor<ExtremeValueGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1245 template<
typename Derived,
typename Urng>
1246 inline const ExtremeValueType<Derived, Urng>
1247 extremeValue(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar a = 0,
typename Derived::Scalar b = 1)
1268 template<
typename Derived,
typename Urng>
1269 inline const ExtremeValueType<Derived, Urng>
1270 extremeValueLike(Derived& o, Urng&& urng,
typename Derived::Scalar a = 0,
typename Derived::Scalar b = 1)
1277 template<
typename Derived,
typename Urng>
1278 using ChiSquaredType = CwiseNullaryOp<internal::scalar_rng_adaptor<ChiSquaredGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1293 template<
typename Derived,
typename Urng>
1294 inline const ChiSquaredType<Derived, Urng>
1295 chiSquared(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar n = 1)
1314 template<
typename Derived,
typename Urng>
1315 inline const ChiSquaredType<Derived, Urng>
1323 template<
typename Derived,
typename Urng>
1324 using FisherFType = CwiseNullaryOp<internal::scalar_rng_adaptor<FisherFGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1340 template<
typename Derived,
typename Urng>
1341 inline const FisherFType<Derived, Urng>
1342 fisherF(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar m = 1,
typename Derived::Scalar n = 1)
1362 template<
typename Derived,
typename Urng>
1363 inline const FisherFType<Derived, Urng>
1364 fisherFLike(Derived& o, Urng&& urng,
typename Derived::Scalar m = 1,
typename Derived::Scalar n = 1)
Generator of reals on a beta distribution.
Definition: NormalExp.h:678
BetaGen(_Scalar _a=1, _Scalar _b=1)
Construct a new beta generator.
Definition: NormalExp.h:694
Generator of reals on a Cauchy distribution.
Definition: NormalExp.h:623
CauchyGen(_Scalar _a=0, _Scalar _b=1)
Construct a new Cauchy generator.
Definition: NormalExp.h:637
Generator of reals on a chi-squared distribution.
Definition: NormalExp.h:581
ChiSquaredGen(_Scalar n=1)
Construct a new chi-squared generator.
Definition: NormalExp.h:592
Generator of reals on an exponential distribution.
Definition: NormalExp.h:256
ExponentialGen(_Scalar _lambda=1)
Construct a new exponential generator.
Definition: NormalExp.h:270
Generator of reals on an extreme value distribution.
Definition: NormalExp.h:531
ExtremeValueGen(_Scalar _a=0, _Scalar _b=1)
Construct a new extreme value generator.
Definition: NormalExp.h:545
Generator of reals on a Fisher's f distribution.
Definition: NormalExp.h:765
FisherFGen(_Scalar m=1, _Scalar n=1)
Construct a new Fisher's f generator.
Definition: NormalExp.h:776
Generator of reals on a gamma distribution.
Definition: NormalExp.h:307
GammaGen(_Scalar _alpha=1, _Scalar _beta=1)
Construct a new gamma generator.
Definition: NormalExp.h:324
Base class of all univariate random generators.
Definition: Basic.h:33
Generator of reals on a lognormal distribution.
Definition: NormalExp.h:141
LognormalGen(_Scalar _mean=0, _Scalar _stdev=1)
Construct a new lognormal generator.
Definition: NormalExp.h:154
Generator of integers on a negative binomial distribution.
Definition: GammaPoisson.h:30
Generator of reals on a normal distribution.
Definition: NormalExp.h:91
NormalGen(_Scalar _mean=0, _Scalar _stdev=1)
Construct a new normal generator.
Definition: NormalExp.h:105
Generator of reals on the standard normal distribution.
Definition: NormalExp.h:27
Generator of reals on a Student's t distribution.
Definition: NormalExp.h:187
StudentTGen(_Scalar _n=1)
Construct a new Student's t generator.
Definition: NormalExp.h:200
Generator of reals on a Weibull distribution.
Definition: NormalExp.h:482
WeibullGen(_Scalar _a=1, _Scalar _b=1)
Construct a new Weibull generator.
Definition: NormalExp.h:496
const GammaType< Derived, Urng > gamma(Index rows, Index cols, Urng &&urng, typename Derived::Scalar alpha=1, typename Derived::Scalar beta=1)
generates reals on a gamma distribution with arbitrary shape and scale parameter.
Definition: NormalExp.h:1150
const ExtremeValueType< Derived, Urng > extremeValueLike(Derived &o, Urng &&urng, typename Derived::Scalar a=0, typename Derived::Scalar b=1)
generates reals on an extreme value distribution (a.k.a Gumbel Type I, log-Weibull,...
Definition: NormalExp.h:1270
const StudentTType< Derived, Urng > studentTLike(Derived &o, Urng &&urng, typename Derived::Scalar n=1)
generates reals on the Student's t distribution with arbirtrary degress of freedom.
Definition: NormalExp.h:1078
const WeibullType< Derived, Urng > weibull(Index rows, Index cols, Urng &&urng, typename Derived::Scalar a=1, typename Derived::Scalar b=1)
generates reals on a Weibull distribution with arbitrary shape and scale parameter.
Definition: NormalExp.h:1198
const LognormalType< Derived, Urng > lognormalLike(Derived &o, Urng &&urng, typename Derived::Scalar mean=0, typename Derived::Scalar stdev=1)
generates reals on a lognormal distribution with arbitrary mean and stdev.
Definition: NormalExp.h:1032
const StudentTType< Derived, Urng > studentT(Index rows, Index cols, Urng &&urng, typename Derived::Scalar n=1)
generates reals on the Student's t distribution with arbirtrary degress of freedom.
Definition: NormalExp.h:1057
const NormalType< Derived, Urng > normal(Index rows, Index cols, Urng &&urng)
generates reals on a standard normal distribution (mean = 0, stdev=1)
Definition: NormalExp.h:916
const ChiSquaredType< Derived, Urng > chiSquaredLike(Derived &o, Urng &&urng, typename Derived::Scalar n=1)
generates reals on the Chi-squared distribution with arbitrary degrees of freedom.
Definition: NormalExp.h:1316
const ExponentialType< Derived, Urng > exponential(Index rows, Index cols, Urng &&urng, typename Derived::Scalar lambda=1)
generates reals on an exponential distribution with arbitrary scale parameter.
Definition: NormalExp.h:1103
const BetaType< Derived, Urng > betaLike(Derived &o, Urng &&urng, typename Derived::Scalar a=1, typename Derived::Scalar b=1)
generates reals on the beta distribution.
Definition: NormalExp.h:844
const CauchyType< Derived, Urng > cauchy(Index rows, Index cols, Urng &&urng, typename Derived::Scalar a=0, typename Derived::Scalar b=1)
generates reals on the Cauchy distribution.
Definition: NormalExp.h:870
const CauchyType< Derived, Urng > cauchyLike(Derived &o, Urng &&urng, typename Derived::Scalar a=0, typename Derived::Scalar b=1)
generates reals on the Cauchy distribution.
Definition: NormalExp.h:892
const FisherFType< Derived, Urng > fisherF(Index rows, Index cols, Urng &&urng, typename Derived::Scalar m=1, typename Derived::Scalar n=1)
generates reals on the Fisher's F distribution.
Definition: NormalExp.h:1342
const WeibullType< Derived, Urng > weibullLike(Derived &o, Urng &&urng, typename Derived::Scalar a=1, typename Derived::Scalar b=1)
generates reals on a Weibull distribution with arbitrary shape and scale parameter.
Definition: NormalExp.h:1220
const FisherFType< Derived, Urng > fisherFLike(Derived &o, Urng &&urng, typename Derived::Scalar m=1, typename Derived::Scalar n=1)
generates reals on the Fisher's F distribution.
Definition: NormalExp.h:1364
const NormalType< Derived, Urng > normalLike(Derived &o, Urng &&urng)
generates reals on a standard normal distribution (mean = 0, stdev=1)
Definition: NormalExp.h:936
const LognormalType< Derived, Urng > lognormal(Index rows, Index cols, Urng &&urng, typename Derived::Scalar mean=0, typename Derived::Scalar stdev=1)
generates reals on a lognormal distribution with arbitrary mean and stdev.
Definition: NormalExp.h:1010
const BetaType< Derived, Urng > beta(Index rows, Index cols, Urng &&urng, typename Derived::Scalar a=1, typename Derived::Scalar b=1)
generates reals on the beta distribution.
Definition: NormalExp.h:823
const ExponentialType< Derived, Urng > exponentialLike(Derived &o, Urng &&urng, typename Derived::Scalar lambda=1)
generates reals on an exponential distribution with arbitrary scale parameter.
Definition: NormalExp.h:1124
const ExtremeValueType< Derived, Urng > extremeValue(Index rows, Index cols, Urng &&urng, typename Derived::Scalar a=0, typename Derived::Scalar b=1)
generates reals on an extreme value distribution (a.k.a Gumbel Type I, log-Weibull,...
Definition: NormalExp.h:1247
const GammaType< Derived, Urng > gammaLike(Derived &o, Urng &&urng, typename Derived::Scalar alpha=1, typename Derived::Scalar beta=1)
generates reals on a gamma distribution with arbitrary shape and scale parameter.
Definition: NormalExp.h:1172
const ChiSquaredType< Derived, Urng > chiSquared(Index rows, Index cols, Urng &&urng, typename Derived::Scalar n=1)
generates reals on the Chi-squared distribution with arbitrary degrees of freedom.
Definition: NormalExp.h:1295