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>();
47 for (
int _i = 0; ; ++_i)
49 EIGENRAND_CHECK_INFINITY_LOOP();
52 sx = v1 * v1 + v2 * v2;
53 if (sx && sx < 1)
break;
55 _Scalar fx = std::sqrt((_Scalar)-2.0 * std::log(sx) / sx);
56 OptCacheStore::get<_Scalar>() = fx * v2;
60 template<
typename Packet,
typename Rng>
61 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
63 using namespace Eigen::internal;
67 return OptCacheStore::template get<Packet>();
70 Packet u1 = ur.template packetOp<Packet>(rng),
71 u2 = ur.template packetOp<Packet>(rng);
73 u1 = psub(pset1<Packet>(1), u1);
75 auto radius = psqrt(pmul(pset1<Packet>(-2), plog(u1)));
76 auto theta = pmul(pset1<Packet>(2 * constant::pi), u2);
77 Packet sintheta, costheta;
79 psincos(theta, sintheta, costheta);
80 OptCacheStore::template get<Packet>() = pmul(radius, costheta);
81 return pmul(radius, sintheta);
90 template<
typename _Scalar>
93 static_assert(std::is_floating_point<_Scalar>::value,
"normalDist needs floating point types.");
95 _Scalar mean = 0, stdev = 1;
98 using Scalar = _Scalar;
107 : mean{ _mean }, stdev{ _stdev }
117 template<
typename Rng>
118 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
120 using namespace Eigen::internal;
121 return stdnorm(std::forward<Rng>(rng)) * stdev + mean;
124 template<
typename Packet,
typename Rng>
125 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
127 using namespace Eigen::internal;
129 stdnorm.template packetOp<Packet>(std::forward<Rng>(rng)),
131 ), pset1<Packet>(mean));
140 template<
typename _Scalar>
143 static_assert(std::is_floating_point<_Scalar>::value,
"lognormalDist needs floating point types.");
147 using Scalar = _Scalar;
156 : norm{ _mean, _stdev }
166 template<
typename Rng>
167 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
169 using namespace Eigen::internal;
170 return std::exp(norm(std::forward<Rng>(rng)));
173 template<
typename Packet,
typename Rng>
174 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
176 using namespace Eigen::internal;
177 return pexp(norm.template packetOp<Packet>(std::forward<Rng>(rng)));
186 template<
typename _Scalar>
189 static_assert(std::is_floating_point<_Scalar>::value,
"studentT needs floating point types.");
194 using Scalar = _Scalar;
212 template<
typename Rng>
213 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
215 using namespace Eigen::internal;
217 for (
int _i = 0; ; ++_i)
219 EIGENRAND_CHECK_INFINITY_LOOP();
220 v1 = 2 * ur(rng) - 1;
221 v2 = 2 * ur(rng) - 1;
222 sx = v1 * v1 + v2 * v2;
223 if (sx && sx < 1)
break;
226 _Scalar fx = std::sqrt(n * (std::pow(sx, -2 / n) - 1) / sx);
230 template<
typename Packet,
typename Rng>
231 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
233 using namespace Eigen::internal;
234 Packet u1 = ur.template packetOp<Packet>(rng),
235 u2 = ur.template packetOp<Packet>(rng);
237 u1 = psub(pset1<Packet>(1), u1);
238 auto pn = pset1<Packet>(n);
239 auto radius = psqrt(pmul(pn,
240 psub(pexp(pmul(plog(u1), pset1<Packet>(-2 / n))), pset1<Packet>(1))
242 auto theta = pmul(pset1<Packet>(2 * constant::pi), u2);
245 return pmul(radius, psin(theta));
249 template<
typename>
class GammaGen;
256 template<
typename _Scalar>
260 static_assert(std::is_floating_point<_Scalar>::value,
"expDist needs floating point types.");
265 using Scalar = _Scalar;
283 template<
typename Rng>
284 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
286 using namespace Eigen::internal;
287 return -std::log(1 - ur(std::forward<Rng>(rng))) / lambda;
290 template<
typename Packet,
typename Rng>
291 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
293 using namespace Eigen::internal;
294 return pnegate(pdiv(plog(
295 psub(pset1<Packet>(1), ur.template packetOp<Packet>(std::forward<Rng>(rng)))
296 ), pset1<Packet>(lambda)));
300 template<
typename>
class NegativeBinomialGen;
307 template<
typename _Scalar>
310 template<
typename _Ty>
312 static_assert(std::is_floating_point<_Scalar>::value,
"gammaDist needs floating point types.");
313 int cache_rest_cnt = 0;
315 _Scalar alpha,
beta, px, sqrt;
318 using Scalar = _Scalar;
327 : alpha{ _alpha },
beta{ _beta }
329 px = (_Scalar)(constant::e / (alpha + constant::e));
330 sqrt = std::sqrt(2 * alpha - 1);
339 template<
typename Rng>
340 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
342 using namespace Eigen::internal;
345 _Scalar ux, vx, xx, qx;
346 for (
int _i = 0; ; ++_i)
348 EIGENRAND_CHECK_INFINITY_LOOP();
350 vx = expon.ur.nzur_scalar(rng);
354 xx = std::pow(vx, 1 / alpha);
359 xx = 1 - std::log(vx);
360 qx = std::pow(xx, alpha - 1);
363 if (expon.ur(rng) < qx)
371 return beta * expon(rng);
374 if ((count = alpha) == alpha && count < 20)
377 yx = expon.ur.nzur_scalar(rng);
380 yx *= expon.ur.nzur_scalar(rng);
382 return -
beta * std::log(yx);
385 for (
int _i = 0; ; ++_i)
387 EIGENRAND_CHECK_INFINITY_LOOP();
389 yx = std::tan(constant::pi * expon.ur(rng));
390 xx = sqrt * yx + alpha - 1;
391 if (xx <= 0)
continue;
392 if (expon.ur(rng) <= (1 + yx * yx)
393 * std::exp((alpha - 1) * std::log(xx / (alpha - 1)) - sqrt * yx))
400 template<
typename Packet,
typename Rng>
401 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
403 using namespace Eigen::internal;
404 using RUtils = RandUtils<Packet, Rng>;
405 auto& cm = Rand::detail::CompressMask<
sizeof(Packet)>::get_inst();
410 for (
int _i = 0; ; ++_i)
412 EIGENRAND_CHECK_INFINITY_LOOP();
413 Packet ux = ru.uniform_real(rng);
414 Packet vx = ru.nonzero_uniform_real(rng);
416 Packet xx = pexp(pmul(pset1<Packet>(1 / alpha), plog(vx)));
417 Packet qx = pexp(pnegate(xx));
419 Packet xx2 = psub(pset1<Packet>(1), plog(vx));
420 Packet qx2 = pexp(pmul(plog(xx2), pset1<Packet>(alpha - 1)));
422 auto c = pcmplt(ux, pset1<Packet>(px));
423 xx = pblendv(c, xx, xx2);
424 qx = pblendv(c, qx, qx2);
426 ux = ru.uniform_real(rng);
427 Packet cands = pmul(pset1<Packet>(
beta), xx);
429 cache_rest_cnt = cm.compress_append(cands, pcmplt(ux, qx),
430 OptCacheStore::template get<Packet>(), cache_rest_cnt, full);
431 if (full)
return cands;
436 return pmul(pset1<Packet>(
beta),
437 expon.template packetOp<Packet>(rng)
441 if ((count = alpha) == alpha && count < 20)
445 yx = ru.nonzero_uniform_real(rng);
448 yx = pmul(yx, ru.nonzero_uniform_real(rng));
450 return pnegate(pmul(pset1<Packet>(
beta), plog(yx)));
454 for (
int _i = 0; ; ++_i)
456 EIGENRAND_CHECK_INFINITY_LOOP();
457 Packet alpha_1 = pset1<Packet>(alpha - 1);
459 psincos(pmul(pset1<Packet>(constant::pi), ru.uniform_real(rng)), ys, yc);
460 Packet yx = pdiv(ys, yc);
461 Packet xx = padd(pmul(pset1<Packet>(sqrt), yx), alpha_1);
462 auto c = pcmplt(pset1<Packet>(0), xx);
463 Packet ux = ru.uniform_real(rng);
464 Packet ub = pmul(padd(pmul(yx, yx), pset1<Packet>(1)),
466 pmul(alpha_1, plog(pdiv(xx, alpha_1))),
467 pmul(yx, pset1<Packet>(sqrt))
470 c = pand(c, pcmple(ux, ub));
471 Packet cands = pmul(pset1<Packet>(
beta), xx);
473 cache_rest_cnt = cm.compress_append(cands, c,
474 OptCacheStore::template get<Packet>(), cache_rest_cnt, full);
475 if (full)
return cands;
486 template<
typename _Scalar>
489 static_assert(std::is_floating_point<_Scalar>::value,
"weilbullDist needs floating point types.");
491 _Scalar a = 1, b = 1;
494 using Scalar = _Scalar;
513 template<
typename Rng>
514 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
516 using namespace Eigen::internal;
517 return std::pow(-std::log(1 - ur(std::forward<Rng>(rng))), 1 / a) * b;
520 template<
typename Packet,
typename Rng>
521 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
523 using namespace Eigen::internal;
524 return pmul(pexp(pmul(plog(pnegate(plog(
525 psub(pset1<Packet>(1), ur.template packetOp<Packet>(std::forward<Rng>(rng)))
526 ))), pset1<Packet>(1 / a))), pset1<Packet>(b));
535 template<
typename _Scalar>
538 static_assert(std::is_floating_point<_Scalar>::value,
"extremeValueDist needs floating point types.");
540 _Scalar a = 0, b = 1;
543 using Scalar = _Scalar;
562 template<
typename Rng>
563 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
565 using namespace Eigen::internal;
566 return (a - b * std::log(-std::log(ur.nzur_scalar(std::forward<Rng>(rng)))));
569 template<
typename Packet,
typename Rng>
570 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
572 using namespace Eigen::internal;
573 using RUtils = RandUtils<Packet, Rng>;
574 return psub(pset1<Packet>(a),
575 pmul(plog(pnegate(plog(RUtils{}.nonzero_uniform_real(std::forward<Rng>(rng))))), pset1<Packet>(b))
585 template<
typename _Scalar>
588 static_assert(std::is_floating_point<_Scalar>::value,
"chiSquaredDist needs floating point types.");
591 using Scalar = _Scalar;
599 :
gamma{ n * _Scalar(0.5), 2 }
609 template<
typename Rng>
610 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
615 template<
typename Packet,
typename Rng>
616 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
618 return gamma.template packetOp<Packet>(rng);
627 template<
typename _Scalar>
630 static_assert(std::is_floating_point<_Scalar>::value,
"cauchyDist needs floating point types.");
632 _Scalar a = 0, b = 1;
635 using Scalar = _Scalar;
654 template<
typename Rng>
655 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
657 using namespace Eigen::internal;
658 return a + b * std::tan(constant::pi * (ur(std::forward<Rng>(rng)) - 0.5));
661 template<
typename Packet,
typename Rng>
662 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
664 using namespace Eigen::internal;
666 psincos(pmul(pset1<Packet>(constant::pi),
667 psub(ur.template packetOp<Packet>(std::forward<Rng>(rng)), pset1<Packet>(0.5))
669 return padd(pset1<Packet>(a),
670 pmul(pset1<Packet>(b), pdiv(s, c))
675 template<
typename>
class FisherFGen;
682 template<
typename _Scalar>
686 static_assert(std::is_floating_point<_Scalar>::value,
"betaDist needs floating point types.");
687 int cache_rest_cnt = 0;
693 using Scalar = _Scalar;
712 template<
typename Rng>
713 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
715 using namespace Eigen::internal;
719 for (
int _i = 0; ; ++_i)
721 EIGENRAND_CHECK_INFINITY_LOOP();
722 p1 = std::pow(ur(rng), 1 / a);
723 p2 = std::pow(ur(rng), 1 / b);
731 _Scalar p1 = gd1(rng), p2 = gd2(rng);
732 return p1 / (p1 + p2);
736 template<
typename Packet,
typename Rng>
737 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
739 using namespace Eigen::internal;
742 auto& cm = Rand::detail::CompressMask<
sizeof(Packet)>::get_inst();
744 for (
int _i = 0; ; ++_i)
746 EIGENRAND_CHECK_INFINITY_LOOP();
747 p1 = pexp(pmul(plog(ur.template packetOp<Packet>(rng)), pset1<Packet>(1 / a)));
748 p2 = pexp(pmul(plog(ur.template packetOp<Packet>(rng)), pset1<Packet>(1 / b)));
750 Packet cands = pdiv(p1, x);
752 cache_rest_cnt = cm.compress_append(cands, pcmple(x, pset1<Packet>(1)),
753 OptCacheStore::template get<Packet>(), cache_rest_cnt, full);
754 if (full)
return cands;
759 auto p1 = gd1.template packetOp<Packet>(rng),
760 p2 = gd2.template packetOp<Packet>(rng);
761 return pdiv(p1, padd(p1, p2));
771 template<
typename _Scalar>
774 static_assert(std::is_floating_point<_Scalar>::value,
"fisherF needs floating point types.");
777 using Scalar = _Scalar;
785 :
beta{ m * _Scalar(0.5), n * _Scalar(0.5) }
795 template<
typename Rng>
796 EIGEN_STRONG_INLINE
const _Scalar operator() (Rng&& rng)
798 using namespace Eigen::internal;
799 auto x =
beta(std::forward<Rng>(rng));
800 return beta.b /
beta.a * x / (1 - x);
803 template<
typename Packet,
typename Rng>
804 EIGEN_STRONG_INLINE
const Packet packetOp(Rng&& rng)
806 using namespace Eigen::internal;
807 auto x =
beta.template packetOp<Packet>(std::forward<Rng>(rng));
808 return pdiv(pmul(pset1<Packet>(
beta.b /
beta.a), x), psub(pset1<Packet>(1), x));
813 template<
typename Derived,
typename Urng>
814 using BetaType = CwiseNullaryOp<internal::scalar_rng_adaptor<BetaGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
829 template<
typename Derived,
typename Urng>
830 inline const BetaType<Derived, Urng>
831 beta(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar a = 1,
typename Derived::Scalar b = 1)
850 template<
typename Derived,
typename Urng>
851 inline const BetaType<Derived, Urng>
852 betaLike(Derived& o, Urng&& urng,
typename Derived::Scalar a = 1,
typename Derived::Scalar b = 1)
859 template<
typename Derived,
typename Urng>
860 using CauchyType = CwiseNullaryOp<internal::scalar_rng_adaptor<CauchyGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
876 template<
typename Derived,
typename Urng>
877 inline const CauchyType<Derived, Urng>
878 cauchy(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar a = 0,
typename Derived::Scalar b = 1)
898 template<
typename Derived,
typename Urng>
899 inline const CauchyType<Derived, Urng>
900 cauchyLike(Derived& o, Urng&& urng,
typename Derived::Scalar a = 0,
typename Derived::Scalar b = 1)
907 template<
typename Derived,
typename Urng>
908 using NormalType = CwiseNullaryOp<internal::scalar_rng_adaptor<StdNormalGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
922 template<
typename Derived,
typename Urng>
923 inline const NormalType<Derived, Urng>
924 normal(Index rows, Index cols, Urng&& urng)
927 rows, cols, { std::forward<Urng>(urng) }
942 template<
typename Derived,
typename Urng>
943 inline const NormalType<Derived, Urng>
947 o.rows(), o.cols(), { std::forward<Urng>(urng) }
951 template<
typename Derived,
typename Urng>
952 using Normal2Type = CwiseNullaryOp<internal::scalar_rng_adaptor<NormalGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
968 template<
typename Derived,
typename Urng>
969 inline const Normal2Type<Derived, Urng>
970 normal(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar mean,
typename Derived::Scalar stdev = 1)
990 template<
typename Derived,
typename Urng>
991 inline const Normal2Type<Derived, Urng>
992 normalLike(Derived& o, Urng&& urng,
typename Derived::Scalar mean,
typename Derived::Scalar stdev = 1)
999 template<
typename Derived,
typename Urng>
1000 using LognormalType = CwiseNullaryOp<internal::scalar_rng_adaptor<LognormalGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1016 template<
typename Derived,
typename Urng>
1017 inline const LognormalType<Derived, Urng>
1018 lognormal(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar mean = 0,
typename Derived::Scalar stdev = 1)
1038 template<
typename Derived,
typename Urng>
1039 inline const LognormalType<Derived, Urng>
1040 lognormalLike(Derived& o, Urng&& urng,
typename Derived::Scalar mean = 0,
typename Derived::Scalar stdev = 1)
1047 template<
typename Derived,
typename Urng>
1048 using StudentTType = CwiseNullaryOp<internal::scalar_rng_adaptor<StudentTGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1063 template<
typename Derived,
typename Urng>
1064 inline const StudentTType<Derived, Urng>
1065 studentT(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar n = 1)
1084 template<
typename Derived,
typename Urng>
1085 inline const StudentTType<Derived, Urng>
1093 template<
typename Derived,
typename Urng>
1094 using ExponentialType = CwiseNullaryOp<internal::scalar_rng_adaptor<ExponentialGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1109 template<
typename Derived,
typename Urng>
1110 inline const ExponentialType<Derived, Urng>
1111 exponential(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar lambda = 1)
1130 template<
typename Derived,
typename Urng>
1131 inline const ExponentialType<Derived, Urng>
1139 template<
typename Derived,
typename Urng>
1140 using GammaType = CwiseNullaryOp<internal::scalar_rng_adaptor<GammaGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1156 template<
typename Derived,
typename Urng>
1157 inline const GammaType<Derived, Urng>
1158 gamma(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar alpha = 1,
typename Derived::Scalar
beta = 1)
1178 template<
typename Derived,
typename Urng>
1179 inline const GammaType<Derived, Urng>
1180 gammaLike(Derived& o, Urng&& urng,
typename Derived::Scalar alpha = 1,
typename Derived::Scalar
beta = 1)
1187 template<
typename Derived,
typename Urng>
1188 using WeibullType = CwiseNullaryOp<internal::scalar_rng_adaptor<WeibullGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1204 template<
typename Derived,
typename Urng>
1205 inline const WeibullType<Derived, Urng>
1206 weibull(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar a = 1,
typename Derived::Scalar b = 1)
1226 template<
typename Derived,
typename Urng>
1227 inline const WeibullType<Derived, Urng>
1228 weibullLike(Derived& o, Urng&& urng,
typename Derived::Scalar a = 1,
typename Derived::Scalar b = 1)
1235 template<
typename Derived,
typename Urng>
1236 using ExtremeValueType = CwiseNullaryOp<internal::scalar_rng_adaptor<ExtremeValueGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1253 template<
typename Derived,
typename Urng>
1254 inline const ExtremeValueType<Derived, Urng>
1255 extremeValue(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar a = 0,
typename Derived::Scalar b = 1)
1276 template<
typename Derived,
typename Urng>
1277 inline const ExtremeValueType<Derived, Urng>
1278 extremeValueLike(Derived& o, Urng&& urng,
typename Derived::Scalar a = 0,
typename Derived::Scalar b = 1)
1285 template<
typename Derived,
typename Urng>
1286 using ChiSquaredType = CwiseNullaryOp<internal::scalar_rng_adaptor<ChiSquaredGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1301 template<
typename Derived,
typename Urng>
1302 inline const ChiSquaredType<Derived, Urng>
1303 chiSquared(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar n = 1)
1322 template<
typename Derived,
typename Urng>
1323 inline const ChiSquaredType<Derived, Urng>
1331 template<
typename Derived,
typename Urng>
1332 using FisherFType = CwiseNullaryOp<internal::scalar_rng_adaptor<FisherFGen<typename Derived::Scalar>,
typename Derived::Scalar, Urng,
true>,
const Derived>;
1348 template<
typename Derived,
typename Urng>
1349 inline const FisherFType<Derived, Urng>
1350 fisherF(Index rows, Index cols, Urng&& urng,
typename Derived::Scalar m = 1,
typename Derived::Scalar n = 1)
1370 template<
typename Derived,
typename Urng>
1371 inline const FisherFType<Derived, Urng>
1372 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:684
BetaGen(_Scalar _a=1, _Scalar _b=1)
Construct a new beta generator.
Definition: NormalExp.h:700
Generator of reals on a Cauchy distribution.
Definition: NormalExp.h:629
CauchyGen(_Scalar _a=0, _Scalar _b=1)
Construct a new Cauchy generator.
Definition: NormalExp.h:643
Generator of reals on a chi-squared distribution.
Definition: NormalExp.h:587
ChiSquaredGen(_Scalar n=1)
Construct a new chi-squared generator.
Definition: NormalExp.h:598
Generator of reals on an exponential distribution.
Definition: NormalExp.h:258
ExponentialGen(_Scalar _lambda=1)
Construct a new exponential generator.
Definition: NormalExp.h:272
Generator of reals on an extreme value distribution.
Definition: NormalExp.h:537
ExtremeValueGen(_Scalar _a=0, _Scalar _b=1)
Construct a new extreme value generator.
Definition: NormalExp.h:551
Generator of reals on a Fisher's f distribution.
Definition: NormalExp.h:773
FisherFGen(_Scalar m=1, _Scalar n=1)
Construct a new Fisher's f generator.
Definition: NormalExp.h:784
Generator of reals on a gamma distribution.
Definition: NormalExp.h:309
GammaGen(_Scalar _alpha=1, _Scalar _beta=1)
Construct a new gamma generator.
Definition: NormalExp.h:326
Base class of all univariate random generators.
Definition: Basic.h:33
Generator of reals on a lognormal distribution.
Definition: NormalExp.h:142
LognormalGen(_Scalar _mean=0, _Scalar _stdev=1)
Construct a new lognormal generator.
Definition: NormalExp.h:155
Generator of integers on a negative binomial distribution.
Definition: GammaPoisson.h:30
Generator of reals on a normal distribution.
Definition: NormalExp.h:92
NormalGen(_Scalar _mean=0, _Scalar _stdev=1)
Construct a new normal generator.
Definition: NormalExp.h:106
Generator of reals on the standard normal distribution.
Definition: NormalExp.h:27
Generator of reals on a Student's t distribution.
Definition: NormalExp.h:188
StudentTGen(_Scalar _n=1)
Construct a new Student's t generator.
Definition: NormalExp.h:201
Generator of reals on a Weibull distribution.
Definition: NormalExp.h:488
WeibullGen(_Scalar _a=1, _Scalar _b=1)
Construct a new Weibull generator.
Definition: NormalExp.h:502
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:1158
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:1278
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:1086
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:1206
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:1040
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:1065
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:924
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:1324
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:1111
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:852
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:878
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:900
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:1350
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:1228
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:1372
const NormalType< Derived, Urng > normalLike(Derived &o, Urng &&urng)
generates reals on a standard normal distribution (mean = 0, stdev=1)
Definition: NormalExp.h:944
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:1018
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:831
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:1132
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:1255
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:1180
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:1303