tomoto 0.2.2 → 0.3.0

data/vendor/EigenRand/EigenRand/Core.h

@@ -2,10 +2,10 @@
  * @file Core.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.3.0
- * @date 2020-10-07
+ * @version 0.3.3
+ * @date 2021-03-31
  * 
- * @copyright Copyright (c) 2020
+ * @copyright Copyright (c) 2020-2021
  * 
  */
 
@@ -13,15 +13,15 @@
 #ifndef EIGENRAND_CORE_H
 #define EIGENRAND_CORE_H
 
-#include <EigenRand/RandUtils.h>
+#include "RandUtils.h"
 
-#include <EigenRand/Dists/Basic.h>
-#include <EigenRand/Dists/Discrete.h>
-#include <EigenRand/Dists/NormalExp.h>
-#include <EigenRand/Dists/GammaPoisson.h>
+#include "Dists/Basic.h"
+#include "Dists/Discrete.h"
+#include "Dists/NormalExp.h"
+#include "Dists/GammaPoisson.h"
 
-#include <EigenRand/MvDists/MvNormal.h>
-#include <EigenRand/MvDists/Multinomial.h>
+#include "MvDists/MvNormal.h"
+#include "MvDists/Multinomial.h"
 
 namespace Eigen
 {

data/vendor/EigenRand/EigenRand/Dists/Basic.h

@@ -2,10 +2,10 @@
  * @file Basic.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.3.0
- * @date 2020-10-07
+ * @version 0.3.3
+ * @date 2021-03-31
  * 
- * @copyright Copyright (c) 2020
+ * @copyright Copyright (c) 2020-2021
  * 
  */
 
@@ -238,6 +238,31 @@ namespace Eigen
 
 		using OptCacheStore = CacheStore<EIGEN_MAX_ALIGN_BYTES>;
 
+		template<typename _Scalar>
+		struct ExtractFirstUint;
+
+		template<>
+		struct ExtractFirstUint<float>
+		{
+			template<typename Packet>
+			auto operator()(Packet v) -> decltype(Eigen::internal::pfirst(v))
+			{
+				return Eigen::internal::pfirst(v);
+			}
+		};
+
+		template<>
+		struct ExtractFirstUint<double>
+		{
+			template<typename Packet>
+			auto operator()(Packet v) -> uint64_t
+			{
+				uint64_t arr[sizeof(Packet) / 8];
+				Eigen::internal::pstoreu((Packet*)arr, v);
+				return arr[0];
+			}
+		};
+
 		/**
 		 * @brief Generator of random bits for integral scalars
 		 * 
@@ -296,13 +321,52 @@ namespace Eigen
 			}
 		};
 
+		/**
+		 * @brief Generator of reals in a range `[a, b]`
+		 *
+		 * @tparam _Scalar any real type
+		 */
+		template<typename _Scalar>
+		class Balanced2Gen : public GenBase<Balanced2Gen<_Scalar>, _Scalar>
+		{
+			static_assert(std::is_floating_point<_Scalar>::value, "balanced needs floating point types.");
+			_Scalar slope = 2, bias = -1;
+		public:
+			using Scalar = _Scalar;
+
+			/**
+			 * @brief Construct a new balanced generator
+			 *
+			 * @param _a,_b left and right boundary
+			 */
+			Balanced2Gen(_Scalar _a = -1, _Scalar _b = 1)
+				: slope{ _b - _a }, bias{ _a }
+			{
+			}
+
+			template<typename Rng>
+			EIGEN_STRONG_INLINE const _Scalar operator() (Rng&& rng)
+			{
+				using namespace Eigen::internal;
+				return ((_Scalar)((int32_t)pfirst(std::forward<Rng>(rng)()) & 0x7FFFFFFF) / 0x7FFFFFFF) * slope + bias;
+			}
+
+			template<typename Packet, typename Rng>
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(Rng&& rng)
+			{
+				using namespace Eigen::internal;
+				using RUtils = RandUtils<Packet, Rng>;
+				return RUtils{}.balanced(std::forward<Rng>(rng), slope, bias);
+			}
+		};
+
 		/**
 		 * @brief Generator of reals in a range `[0, 1)`
 		 * 
 		 * @tparam _Scalar any real type
 		 */
 		template<typename _Scalar>
-		class UniformRealGen : public GenBase<UniformRealGen<_Scalar>, _Scalar>
+		class StdUniformRealGen : public GenBase<StdUniformRealGen<_Scalar>, _Scalar>
 		{
 			static_assert(std::is_floating_point<_Scalar>::value, "uniformReal needs floating point types.");
 
@@ -313,14 +377,14 @@ namespace Eigen
 			EIGEN_STRONG_INLINE const _Scalar operator() (Rng&& rng)
 			{
 				using namespace Eigen::internal;
-				return bit_scalar<_Scalar>{}.to_ur(pfirst(std::forward<Rng>(rng)()));
+				return BitScalar<_Scalar>{}.to_ur(ExtractFirstUint<_Scalar>{}(std::forward<Rng>(rng)()));
 			}
 
 			template<typename Rng>
 			EIGEN_STRONG_INLINE const _Scalar nzur_scalar(Rng&& rng)
 			{
 				using namespace Eigen::internal;
-				return bit_scalar<_Scalar>{}.to_nzur(pfirst(std::forward<Rng>(rng)()));
+				return BitScalar<_Scalar>{}.to_nzur(ExtractFirstUint<_Scalar>{}(std::forward<Rng>(rng)()));
 			}
 
 			template<typename Packet, typename Rng>
@@ -332,6 +396,49 @@ namespace Eigen
 			}
 		};
 
+		/**
+		 * @brief Generator of reals in a range `[a, b)`
+		 * 
+		 * @tparam _Scalar any real type
+		 */
+		template<typename _Scalar>
+		class UniformRealGen : public GenBase<UniformRealGen<_Scalar>, _Scalar>
+		{
+			static_assert(std::is_floating_point<_Scalar>::value, "uniformReal needs floating point types.");
+			_Scalar bias, slope;
+
+		public:
+			using Scalar = _Scalar;
+
+			UniformRealGen(_Scalar _min = 0, _Scalar _max = 1)
+				: bias{ _min }, slope{ _max - _min }
+			{
+			}
+
+			UniformRealGen(const UniformRealGen&) = default;
+			UniformRealGen(UniformRealGen&&) = default;
+
+			UniformRealGen& operator=(const UniformRealGen&) = default;
+			UniformRealGen& operator=(UniformRealGen&&) = default;
+
+			template<typename Rng>
+			EIGEN_STRONG_INLINE const _Scalar operator() (Rng&& rng)
+			{
+				using namespace Eigen::internal;
+				return bias + BitScalar<_Scalar>{}.to_ur(pfirst(std::forward<Rng>(rng)())) * slope;
+			}
+
+			template<typename Packet, typename Rng>
+			EIGEN_STRONG_INLINE const Packet packetOp(Rng&& rng)
+			{
+				using namespace Eigen::internal;
+				using RUtils = RandUtils<Packet, Rng>;
+				return padd(pmul(
+					RUtils{}.uniform_real(std::forward<Rng>(rng)), pset1<Packet>(slope)
+				), pset1<Packet>(bias));
+			}
+		};
+
 
 		/**
 		 * @brief Generator of Bernoulli distribution
@@ -468,7 +575,53 @@ namespace Eigen
 		}
 
 		template<typename Derived, typename Urng>
-		using UniformRealType = CwiseNullaryOp<internal::scalar_rng_adaptor<UniformRealGen<typename Derived::Scalar>, typename Derived::Scalar, Urng, true>, const Derived>;
+		using Balanced2Type = CwiseNullaryOp<internal::scalar_rng_adaptor<Balanced2Gen<typename Derived::Scalar>, typename Derived::Scalar, Urng, true>, const Derived>;
+
+		/**
+		 * @brief generates reals in a range `[a, b]`
+		 *
+		 * @tparam Derived a type of Eigen::DenseBase
+		 * @tparam Urng
+		 * @param rows the number of rows being generated
+		 * @param cols the number of columns being generated
+		 * @param urng c++11-style random number generator
+		 * @param a,b left and right boundary
+		 * @return a random matrix expression with a shape (`rows`, `cols`)
+		 *
+		 * @see Eigen::Rand::BalancedGen
+		 */
+		template<typename Derived, typename Urng>
+		inline const Balanced2Type<Derived, Urng>
+			balanced(Index rows, Index cols, Urng&& urng, typename Derived::Scalar a, typename Derived::Scalar b)
+		{
+			return {
+				rows, cols, { std::forward<Urng>(urng), Balanced2Gen<typename Derived::Scalar>{a, b} }
+			};
+		}
+
+		/**
+		 * @brief generates reals in a range `[a, b]`
+		 *
+		 * @tparam Derived
+		 * @tparam Urng
+		 * @param o an instance of any type of Eigen::DenseBase
+		 * @param urng c++11-style random number generator
+		 * @param a,b left and right boundary
+		 * @return a random matrix expression of the same shape as `o`
+		 *
+		 * @see Eigen::Rand::BalancedGen
+		 */
+		template<typename Derived, typename Urng>
+		inline const Balanced2Type<Derived, Urng>
+			balancedLike(const Derived& o, Urng&& urng, typename Derived::Scalar a, typename Derived::Scalar b)
+		{
+			return {
+				o.rows(), o.cols(), { std::forward<Urng>(urng), Balanced2Gen<typename Derived::Scalar>{a, b} }
+			};
+		}
+
+		template<typename Derived, typename Urng>
+		using StdUniformRealType = CwiseNullaryOp<internal::scalar_rng_adaptor<StdUniformRealGen<typename Derived::Scalar>, typename Derived::Scalar, Urng, true>, const Derived>;
 
 		/**
 		 * @brief generates reals in a range `[0, 1)`
@@ -483,7 +636,7 @@ namespace Eigen
 		 * @see Eigen::Rand::UniformRealGen
 		 */
 		template<typename Derived, typename Urng>
-		inline const UniformRealType<Derived, Urng>
+		inline const StdUniformRealType<Derived, Urng>
 			uniformReal(Index rows, Index cols, Urng&& urng)
 		{
 			return {
@@ -503,7 +656,7 @@ namespace Eigen
 		 * @see Eigen::Rand::UniformRealGen
 		 */
 		template<typename Derived, typename Urng>
-		inline const UniformRealType<Derived, Urng>
+		inline const StdUniformRealType<Derived, Urng>
 			uniformRealLike(Derived& o, Urng&& urng)
 		{
 			return {
@@ -511,6 +664,52 @@ namespace Eigen
 			};
 		}
 
+		template<typename Derived, typename Urng>
+		using UniformRealType = CwiseNullaryOp<internal::scalar_rng_adaptor<UniformRealGen<typename Derived::Scalar>, typename Derived::Scalar, Urng, true>, const Derived>;
+
+		/**
+		 * @brief generates reals in a range `[min, max)`
+		 *
+		 * @tparam Derived a type of Eigen::DenseBase
+		 * @tparam Urng
+		 * @param rows the number of rows being generated
+		 * @param cols the number of columns being generated
+		 * @param urng c++11-style random number generator
+		 * @param min, max the range of reals being generated
+		 * @return a random matrix expression with a shape (`rows`, `cols`)
+		 *
+		 * @see Eigen::Rand::UniformRealGen
+		 */
+		template<typename Derived, typename Urng>
+		inline const UniformRealType<Derived, Urng>
+			uniformReal(Index rows, Index cols, Urng&& urng, typename Derived::Scalar min, typename Derived::Scalar max)
+		{
+			return {
+				rows, cols, { std::forward<Urng>(urng), UniformRealGen<typename Derived::Scalar>{ min, max } }
+			};
+		}
+
+		/**
+		 * @brief generates reals in a range `[min, max)`
+		 *
+		 * @tparam Derived
+		 * @tparam Urng
+		 * @param o an instance of any type of Eigen::DenseBase
+		 * @param urng c++11-style random number generator
+		 * @param min, max the range of reals being generated
+		 * @return a random matrix expression of the same shape as `o`
+		 *
+		 * @see Eigen::Rand::UniformRealGen
+		 */
+		template<typename Derived, typename Urng>
+		inline const UniformRealType<Derived, Urng>
+			uniformRealLike(Derived& o, Urng&& urng, typename Derived::Scalar min, typename Derived::Scalar max)
+		{
+			return {
+				o.rows(), o.cols(), { std::forward<Urng>(urng), UniformRealGen<typename Derived::Scalar>{ min, max } }
+			};
+		}
+
 		template<typename Derived, typename Urng>
 		using BernoulliType = CwiseNullaryOp<internal::scalar_rng_adaptor<BernoulliGen<typename Derived::Scalar>, typename Derived::Scalar, Urng, true>, const Derived>;
 

data/vendor/EigenRand/EigenRand/Dists/Discrete.h

@@ -2,10 +2,10 @@
  * @file Discrete.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.3.0
- * @date 2020-10-07
+ * @version 0.3.3
+ * @date 2021-03-31
  *
- * @copyright Copyright (c) 2020
+ * @copyright Copyright (c) 2020-2021
  * 
  */
 
@@ -49,11 +49,11 @@ namespace Eigen
 				bitmask = o.bitmask;
 				if (msize)
 				{
-					arr = std::unique_ptr<_Precision[]>(new _Precision[1 << bitsize]);
-					alias = std::unique_ptr<_Size[]>(new _Size[1 << bitsize]);
+					arr = std::unique_ptr<_Precision[]>(new _Precision[(size_t)1 << bitsize]);
+					alias = std::unique_ptr<_Size[]>(new _Size[(size_t)1 << bitsize]);
 
-					std::copy(o.arr.get(), o.arr.get() + (1 << bitsize), arr.get());
-					std::copy(o.alias.get(), o.alias.get() + (1 << bitsize), alias.get());
+					std::copy(o.arr.get(), o.arr.get() + ((size_t)1 << bitsize), arr.get());
+					std::copy(o.alias.get(), o.alias.get() + ((size_t)1 << bitsize), alias.get());
 				}
 				return *this;
 			}
@@ -125,7 +125,7 @@ namespace Eigen
 					{
 						arr[under] = (_Precision)f[under];
 					}
-					alias[under] = over;
+					alias[under] = (_Size)over;
 					f[over] += f[under] - 1;
 					if (f[over] >= 1 || mm <= over)
 					{
@@ -152,7 +152,7 @@ namespace Eigen
 						{
 							arr[over] = 1;
 						}
-						alias[over] = over;
+						alias[over] = (_Size)over;
 					}
 				}
 
@@ -166,7 +166,7 @@ namespace Eigen
 					{
 						arr[under] = 1;
 					}
-					alias[under] = under;
+					alias[under] = (_Size)under;
 					for (under = mm; under < msize; ++under)
 					{
 						if (f[under] < 1)
@@ -179,7 +179,7 @@ namespace Eigen
 							{
 								arr[under] = 1;
 							}
-							alias[under] = under;
+							alias[under] = (_Size)under;
 						}
 					}
 				}
@@ -260,8 +260,9 @@ namespace Eigen
 				else
 				{
 					size_t bitcnt = bitsize;
-					while (1)
+					for (int _i = 0; ; ++_i)
 					{
+						EIGENRAND_CHECK_INFINITY_LOOP();
 						_Scalar cands = (_Scalar)(rx & bitmask);
 						if (cands <= pdiff) return cands;
 						if (bitcnt + bitsize < 32)
@@ -293,8 +294,9 @@ namespace Eigen
 					auto& cm = Rand::detail::CompressMask<sizeof(Packet)>::get_inst();
 					auto plen = pset1<Packet>(pdiff + 1);
 					size_t bitcnt = bitsize;
-					while (1)
+					for (int _i = 0; ; ++_i)
 					{
+						EIGENRAND_CHECK_INFINITY_LOOP();
 						// accept cands that only < plen
 						auto cands = pand(rx, pbitmask);
 						bool full = false;
@@ -304,7 +306,7 @@ namespace Eigen
 
 						if (bitcnt + bitsize < 32)
 						{
-							rx = psrl(rx, bitsize);
+							rx = psrl<-1>(rx, bitsize);
 							bitcnt += bitsize;
 						}
 						else
@@ -417,7 +419,7 @@ namespace Eigen
 					auto rx = randbits(std::forward<Rng>(rng));
 					auto albit = rx & alias_table.get_bitmask();
 					uint32_t alx = (uint32_t)(rx >> (sizeof(rx) * 8 - 31));
-					if (alx < alias_table.get_prob()[albit]) return albit;
+					if (alx < alias_table.get_prob()[albit]) return (_Scalar)albit;
 					return alias_table.get_alias()[albit];
 				}
 			}
@@ -451,7 +453,7 @@ namespace Eigen
 				{
 					auto rx = randbits.template packetOp<PacketType>(std::forward<Rng>(rng));
 					auto albit = pand(rx, pset1<PacketType>(alias_table.get_bitmask()));
-					auto c = pcmplt(psrl(rx, 1), pgather(alias_table.get_prob(), albit));
+					auto c = pcmplt(psrl<1>(rx), pgather(alias_table.get_prob(), albit));
 					ret = pblendv(c, albit, pgather(alias_table.get_alias(), albit));
 				}
 
@@ -673,6 +675,8 @@ namespace Eigen
 				}
 			}
 
+#ifdef EIGEN_VECTORIZE_NEON
+#else
 			template<typename Packet, typename Rng>
 			EIGEN_STRONG_INLINE const Packet packetOp(Rng&& rng)
 			{
@@ -681,7 +685,7 @@ namespace Eigen
 				if (!cdf.empty())
 				{
 					auto ret = pset1<Packet>(cdf.size());
-#ifdef EIGEN_VECTORIZE_AVX
+	#ifdef EIGEN_VECTORIZE_AVX
 					auto rx = ur.template packetOp<Packet4d>(std::forward<Rng>(rng));
 					for (auto& p : cdf)
 					{
@@ -689,7 +693,7 @@ namespace Eigen
 						auto r = combine_low32(c);
 						ret = padd(ret, r);
 					}
-#else
+	#else
 					auto rx1 = ur.template packetOp<DPacket>(rng),
 						rx2 = ur.template packetOp<DPacket>(rng);
 					for (auto& p : cdf)
@@ -697,25 +701,26 @@ namespace Eigen
 						auto pp = pset1<decltype(rx1)>(p);
 						ret = padd(ret, combine_low32(reinterpret_to_int(pcmplt(rx1, pp)), reinterpret_to_int(pcmplt(rx2, pp))));
 					}
-#endif
+	#endif
 					return ret;
 				}
 				else
 				{
-#ifdef EIGEN_VECTORIZE_AVX
+	#ifdef EIGEN_VECTORIZE_AVX
 					using RUtils = RawbitsMaker<Packet, Rng>;
 					auto albit = pand(RUtils{}.rawbits(rng), pset1<Packet>(alias_table.get_bitmask()));
 					auto c = reinterpret_to_int(pcmplt(ur.template packetOp<Packet4d>(rng), pgather(alias_table.get_prob(), _mm256_castsi128_si256(albit))));
 					return pblendv(combine_low32(c), albit, pgather(alias_table.get_alias(), albit));
-#else
+	#else
 					using RUtils = RawbitsMaker<Packet, Rng>;
 					auto albit = pand(RUtils{}.rawbits(rng), pset1<Packet>(alias_table.get_bitmask()));
 					auto c1 = reinterpret_to_int(pcmplt(ur.template packetOp<DPacket>(rng), pgather(alias_table.get_prob(), albit)));
 					auto c2 = reinterpret_to_int(pcmplt(ur.template packetOp<DPacket>(rng), pgather(alias_table.get_prob(), albit, true)));
 					return pblendv(combine_low32(c1, c2), albit, pgather(alias_table.get_alias(), albit));
-#endif
+	#endif
 				}
 			}
+#endif
 		};
 
 		template<typename> class BinomialGen;
@@ -777,8 +782,9 @@ namespace Eigen
 				{
 					_Scalar res;
 					double yx;
-					while (1)
+					for (int _i = 0; ; ++_i)
 					{
+						EIGENRAND_CHECK_INFINITY_LOOP();
 						yx = std::tan(constant::pi * ur(rng));
 						res = (_Scalar)(sqrt_tmean * yx + mean);
 						if (res >= 0 && ur(rng) <= 0.9 * (1.0 + yx * yx)
@@ -800,8 +806,9 @@ namespace Eigen
 				{
 					Packet res = pset1<Packet>(0);
 					PacketType val = pset1<PacketType>(1), pne_mean = pset1<PacketType>(ne_mean);
-					while (1)
+					for (int _i = 0; ; ++_i)
 					{
+						EIGENRAND_CHECK_INFINITY_LOOP();
 						val = pmul(val, ur.template packetOp<PacketType>(rng));
 						auto c = reinterpret_to_int(pcmplt(pne_mean, val));
 						if (pmovemask(c) == 0) break;
@@ -817,15 +824,16 @@ namespace Eigen
 						pmean = pset1<PacketType>(mean),
 						plog_mean = pset1<PacketType>(log_mean),
 						pg1 = pset1<PacketType>(g1);
-					while (1)
+					for (int _i = 0; ; ++_i)
 					{
+						EIGENRAND_CHECK_INFINITY_LOOP();
 						PacketType fres, yx, psin, pcos;
 						psincos(pmul(ppi, ur.template packetOp<PacketType>(rng)), psin, pcos);
 						yx = pdiv(psin, pcos);
 						fres = ptruncate(padd(pmul(psqrt_tmean, yx), pmean));
 
 						auto p1 = pmul(padd(pmul(yx, yx), pset1<PacketType>(1)), pset1<PacketType>(0.9));
-						auto p2 = pexp(psub(psub(pmul(fres, plog_mean), plgamma(padd(fres, pset1<PacketType>(1)))), pg1));
+						auto p2 = pexp(psub(psub(pmul(fres, plog_mean), plgamma_approx(padd(fres, pset1<PacketType>(1)))), pg1));
 
 						auto c1 = pcmple(pset1<PacketType>(0), fres);
 						auto c2 = pcmple(ur.template packetOp<PacketType>(rng), pmul(p1, p2));
@@ -852,7 +860,7 @@ namespace Eigen
 
 			PoissonGen<_Scalar> poisson;
 			_Scalar trials;
-			double p, small_p, g1, sqrt_v, log_small_p, log_small_q;
+			double p = 0, small_p = 0, g1 = 0, sqrt_v = 0, log_small_p = 0, log_small_q = 0;
 
 		public:
 			using Scalar = _Scalar;
@@ -903,8 +911,9 @@ namespace Eigen
 				}
 				else
 				{
-					while (1)
+					for (int _i = 0; ; ++_i)
 					{
+						EIGENRAND_CHECK_INFINITY_LOOP();
 						double ys;
 						ys = std::tan(constant::pi * poisson.ur(rng));
 						res = (_Scalar)(sqrt_v * ys + poisson.mean);
@@ -954,8 +963,9 @@ namespace Eigen
 						plog_small_p = pset1<PacketType>(log_small_p),
 						plog_small_q = pset1<PacketType>(log_small_q),
 						pg1 = pset1<PacketType>(g1);
-					while (1)
+					for (int _i = 0; ; ++_i)
 					{
+						EIGENRAND_CHECK_INFINITY_LOOP();
 						PacketType fres, ys, psin, pcos;
 						psincos(pmul(ppi, poisson.ur.template packetOp<PacketType>(rng)), psin, pcos);
 						ys = pdiv(psin, pcos);
@@ -964,8 +974,8 @@ namespace Eigen
 						auto p1 = pmul(pmul(pset1<PacketType>(1.2), psqrt_v), padd(pset1<PacketType>(1), pmul(ys, ys)));
 						auto p2 = pexp(
 							padd(padd(psub(
-								psub(pg1, plgamma(padd(fres, pset1<PacketType>(1)))),
-								plgamma(psub(padd(ptrials, pset1<PacketType>(1)), fres))
+								psub(pg1, plgamma_approx(padd(fres, pset1<PacketType>(1)))),
+								plgamma_approx(psub(padd(ptrials, pset1<PacketType>(1)), fres))
 							), pmul(fres, plog_small_p)), pmul(psub(ptrials, fres), plog_small_q))
 						);
 
@@ -1503,6 +1513,17 @@ namespace Eigen
 			};
 		}
 	}
+
+#ifdef EIGEN_VECTORIZE_NEON
+	namespace internal
+	{
+		template<typename _Scalar, typename Urng, bool _mutable>
+		struct functor_traits<scalar_rng_adaptor<Rand::DiscreteGen<_Scalar, double>, _Scalar, Urng, _mutable> >
+		{
+			enum { Cost = HugeCost, PacketAccess = 0, IsRepeatable = false };
+		};
+	}
+#endif
 }
 
 #endif

data/vendor/EigenRand/EigenRand/Dists/GammaPoisson.h

@@ -2,10 +2,10 @@
  * @file GammaPoisson.h
  * @author bab2min (bab2min@gmail.com)
  * @brief
- * @version 0.3.0
- * @date 2020-10-07
+ * @version 0.3.3
+ * @date 2021-03-31
  *
- * @copyright Copyright (c) 2020
+ * @copyright Copyright (c) 2020-2021
  *
  */
 
@@ -58,7 +58,6 @@ namespace Eigen
 			EIGEN_STRONG_INLINE const Packet packetOp(Rng&& rng)
 			{
 				using namespace Eigen::internal;
-				using ur_base = UniformRealGen<float>;
 				using PacketType = decltype(reinterpret_to_float(std::declval<Packet>()));
 
 				auto mean = gamma.template packetOp<PacketType>(rng);
@@ -66,8 +65,9 @@ namespace Eigen
 				PacketType val = pset1<PacketType>(1), pne_mean = pexp(pnegate(mean));
 				if (pmovemask(pcmplt(pset1<PacketType>(12), mean)) == 0)
 				{
-					while (1)
+					for (int _i = 0; ; ++_i)
 					{
+						EIGENRAND_CHECK_INFINITY_LOOP();
 						val = pmul(val, ur.template packetOp<PacketType>(rng));
 						auto c = reinterpret_to_int(pcmplt(pne_mean, val));
 						if (pmovemask(c) == 0) break;
@@ -81,16 +81,17 @@ namespace Eigen
 					const PacketType ppi = pset1<PacketType>(constant::pi),
 						psqrt_tmean = psqrt(pmul(pset1<PacketType>(2), mean)),
 						plog_mean = plog(mean),
-						pg1 = psub(pmul(mean, plog_mean), plgamma(padd(mean, pset1<PacketType>(1))));
-					while (1)
+						pg1 = psub(pmul(mean, plog_mean), plgamma_approx(padd(mean, pset1<PacketType>(1))));
+					for (int _i = 0; ; ++_i)
 					{
+						EIGENRAND_CHECK_INFINITY_LOOP();
 						PacketType fres, yx, psin, pcos;
 						psincos(pmul(ppi, ur.template packetOp<PacketType>(rng)), psin, pcos);
 						yx = pdiv(psin, pcos);
 						fres = ptruncate(padd(pmul(psqrt_tmean, yx), mean));
 
 						auto p1 = pmul(padd(pmul(yx, yx), pset1<PacketType>(1)), pset1<PacketType>(0.9));
-						auto p2 = pexp(psub(psub(pmul(fres, plog_mean), plgamma(padd(fres, pset1<PacketType>(1)))), pg1));
+						auto p2 = pexp(psub(psub(pmul(fres, plog_mean), plgamma_approx(padd(fres, pset1<PacketType>(1)))), pg1));
 
 						auto c1 = pcmple(pset1<PacketType>(0), fres);
 						auto c2 = pcmple(ur.template packetOp<PacketType>(rng), pmul(p1, p2));