tomoto 0.1.4 → 0.2.0

data/vendor/EigenRand/EigenRand/EigenRand

@@ -2,8 +2,8 @@
  * @file EigenRand
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.2.0
- * @date 2020-06-22
+ * @version 0.3.0
+ * @date 2020-10-07
  * 
  * @copyright Copyright (c) 2020
  * 

data/vendor/EigenRand/EigenRand/Macro.h

@@ -2,8 +2,8 @@
  * @file Macro.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.2.1
- * @date 2020-07-11
+ * @version 0.3.0
+ * @date 2020-10-07
  * 
  * @copyright Copyright (c) 2020
  * 
@@ -13,8 +13,8 @@
 #define EIGENRAND_MACRO_H
 
 #define EIGENRAND_WORLD_VERSION 0
-#define EIGENRAND_MAJOR_VERSION 2
-#define EIGENRAND_MINOR_VERSION 0
+#define EIGENRAND_MAJOR_VERSION 3
+#define EIGENRAND_MINOR_VERSION 2
 
 #if EIGEN_VERSION_AT_LEAST(3,3,7)
 #else

data/vendor/EigenRand/EigenRand/MorePacketMath.h

@@ -2,8 +2,8 @@
  * @file MorePacketMath.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.2.0
- * @date 2020-06-22
+ * @version 0.3.0
+ * @date 2020-10-07
  * 
  * @copyright Copyright (c) 2020
  * 
@@ -195,8 +195,8 @@ namespace Eigen
 		template<typename Packet>
 		EIGEN_STRONG_INLINE Packet pcmple(const Packet& a, const Packet& b);
 
-		template<typename Packet>
-		EIGEN_STRONG_INLINE Packet pblendv(const Packet& ifPacket, const Packet& thenPacket, const Packet& elsePacket);
+		template<typename PacketIf, typename Packet>
+		EIGEN_STRONG_INLINE Packet pblendv(const PacketIf& ifPacket, const Packet& thenPacket, const Packet& elsePacket);
 
 		template<typename Packet>
 		EIGEN_STRONG_INLINE Packet pgather(const int* addr, const Packet& index);
@@ -240,7 +240,7 @@ namespace Eigen
 			return psub(reinterpret_to_double(por(pand(x, lower), upper)), one);
 		}
 
-		template<typename Scalar>
+		template<typename _Scalar>
 		struct bit_scalar;
 
 		template<>
@@ -412,7 +412,7 @@ namespace Eigen
 			Packet4i a1, a2, b1, b2;
 			split_two(a, a1, a2);
 			split_two(b, b1, b2);
-			return combine_two(_mm_cmpeq_epi32(a1, b1), _mm_cmpeq_epi32(a2, b2));
+			return combine_two((Packet4i)_mm_cmpeq_epi32(a1, b1), (Packet4i)_mm_cmpeq_epi32(a2, b2));
 #endif
 		}
 
@@ -424,7 +424,7 @@ namespace Eigen
 #else
 			Packet4i a1, a2;
 			split_two(a, a1, a2);
-			return combine_two(_mm_slli_epi32(a1, b), _mm_slli_epi32(a2, b));
+			return combine_two((Packet4i)_mm_slli_epi32(a1, b), (Packet4i)_mm_slli_epi32(a2, b));
 #endif
 		}
 
@@ -436,7 +436,7 @@ namespace Eigen
 #else
 			Packet4i a1, a2;
 			split_two(a, a1, a2);
-			return combine_two(_mm_srli_epi32(a1, b), _mm_srli_epi32(a2, b));
+			return combine_two((Packet4i)_mm_srli_epi32(a1, b), (Packet4i)_mm_srli_epi32(a2, b));
 #endif
 		}
 
@@ -448,7 +448,7 @@ namespace Eigen
 #else
 			Packet4i a1, a2;
 			split_two(a, a1, a2);
-			return combine_two(_mm_slli_epi64(a1, b), _mm_slli_epi64(a2, b));
+			return combine_two((Packet4i)_mm_slli_epi64(a1, b), (Packet4i)_mm_slli_epi64(a2, b));
 #endif
 		}
 
@@ -460,7 +460,7 @@ namespace Eigen
 #else
 			Packet4i a1, a2;
 			split_two(a, a1, a2);
-			return combine_two(_mm_srli_epi64(a1, b), _mm_srli_epi64(a2, b));
+			return combine_two((Packet4i)_mm_srli_epi64(a1, b), (Packet4i)_mm_srli_epi64(a2, b));
 #endif
 		}
 
@@ -472,7 +472,7 @@ namespace Eigen
 			Packet4i a1, a2, b1, b2;
 			split_two(a, a1, a2);
 			split_two(b, b1, b2);
-			return combine_two(_mm_add_epi32(a1, b1), _mm_add_epi32(a2, b2));
+			return combine_two((Packet4i)_mm_add_epi32(a1, b1), (Packet4i)_mm_add_epi32(a2, b2));
 #endif
 		}
 
@@ -484,7 +484,7 @@ namespace Eigen
 			Packet4i a1, a2, b1, b2;
 			split_two(a, a1, a2);
 			split_two(b, b1, b2);
-			return combine_two(_mm_sub_epi32(a1, b1), _mm_sub_epi32(a2, b2));
+			return combine_two((Packet4i)_mm_sub_epi32(a1, b1), (Packet4i)_mm_sub_epi32(a2, b2));
 #endif
 		}
 
@@ -493,7 +493,7 @@ namespace Eigen
 #ifdef EIGEN_VECTORIZE_AVX2
 			return _mm256_and_si256(a, b);
 #else
-			return reinterpret_to_int(_mm256_and_ps(reinterpret_to_float(a), reinterpret_to_float(b)));
+			return reinterpret_to_int((Packet8f)_mm256_and_ps(reinterpret_to_float(a), reinterpret_to_float(b)));
 #endif
 		}
 
@@ -502,7 +502,7 @@ namespace Eigen
 #ifdef EIGEN_VECTORIZE_AVX2
 			return _mm256_andnot_si256(a, b);
 #else
-			return reinterpret_to_int(_mm256_andnot_ps(reinterpret_to_float(a), reinterpret_to_float(b)));
+			return reinterpret_to_int((Packet8f)_mm256_andnot_ps(reinterpret_to_float(a), reinterpret_to_float(b)));
 #endif
 		}
 
@@ -511,7 +511,7 @@ namespace Eigen
 #ifdef EIGEN_VECTORIZE_AVX2
 			return _mm256_or_si256(a, b);
 #else
-			return reinterpret_to_int(_mm256_or_ps(reinterpret_to_float(a), reinterpret_to_float(b)));
+			return reinterpret_to_int((Packet8f)_mm256_or_ps(reinterpret_to_float(a), reinterpret_to_float(b)));
 #endif
 		}
 
@@ -520,14 +520,21 @@ namespace Eigen
 #ifdef EIGEN_VECTORIZE_AVX2
 			return _mm256_xor_si256(a, b);
 #else
-			return reinterpret_to_int(_mm256_xor_ps(reinterpret_to_float(a), reinterpret_to_float(b)));
+			return reinterpret_to_int((Packet8f)_mm256_xor_ps(reinterpret_to_float(a), reinterpret_to_float(b)));
 #endif
 		}
 
 		template<>
 		EIGEN_STRONG_INLINE Packet8i pcmplt<Packet8i>(const Packet8i& a, const Packet8i& b)
 		{
+#ifdef EIGEN_VECTORIZE_AVX2
 			return _mm256_cmpgt_epi32(b, a);
+#else
+			Packet4i a1, a2, b1, b2;
+			split_two(a, a1, a2);
+			split_two(b, b1, b2);
+			return combine_two((Packet4i)_mm_cmpgt_epi32(b1, a1), (Packet4i)_mm_cmpgt_epi32(b2, a2));
+#endif
 		}
 
 		template<>
@@ -560,6 +567,12 @@ namespace Eigen
 			return _mm256_blendv_ps(elsePacket, thenPacket, ifPacket);
 		}
 
+		template<>
+		EIGEN_STRONG_INLINE Packet8f pblendv(const Packet8i& ifPacket, const Packet8f& thenPacket, const Packet8f& elsePacket)
+		{
+			return pblendv(_mm256_castsi256_ps(ifPacket), thenPacket, elsePacket);
+		}
+
 		template<>
 		EIGEN_STRONG_INLINE Packet8i pblendv(const Packet8i& ifPacket, const Packet8i& thenPacket, const Packet8i& elsePacket)
 		{
@@ -576,6 +589,12 @@ namespace Eigen
 			return _mm256_blendv_pd(elsePacket, thenPacket, ifPacket);
 		}
 
+		template<>
+		EIGEN_STRONG_INLINE Packet4d pblendv(const Packet8i& ifPacket, const Packet4d& thenPacket, const Packet4d& elsePacket)
+		{
+			return pblendv(_mm256_castsi256_pd(ifPacket), thenPacket, elsePacket);
+		}
+
 		template<>
 		EIGEN_STRONG_INLINE Packet8i pgather<Packet8i>(const int* addr, const Packet8i& index)
 		{
@@ -660,7 +679,7 @@ namespace Eigen
 			Packet4i a1, a2, b1, b2;
 			split_two(a, a1, a2);
 			split_two(b, b1, b2);
-			return combine_two(_mm_cmpeq_epi64(a1, b1), _mm_cmpeq_epi64(a2, b2));
+			return combine_two((Packet4i)_mm_cmpeq_epi64(a1, b1), (Packet4i)_mm_cmpeq_epi64(a2, b2));
 #endif
 		}
 
@@ -842,6 +861,12 @@ namespace Eigen
 #endif
 		}
 
+		template<>
+		EIGEN_STRONG_INLINE Packet4f pblendv(const Packet4i& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket)
+		{
+			return pblendv(_mm_castsi128_ps(ifPacket), thenPacket, elsePacket);
+		}
+
 		template<>
 		EIGEN_STRONG_INLINE Packet4i pblendv(const Packet4i& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket)
 		{
@@ -862,6 +887,13 @@ namespace Eigen
 #endif
 		}
 
+
+		template<>
+		EIGEN_STRONG_INLINE Packet2d pblendv(const Packet4i& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket)
+		{
+			return pblendv(_mm_castsi128_pd(ifPacket), thenPacket, elsePacket);
+		}
+
 		template<>
 		EIGEN_STRONG_INLINE Packet4i pgather<Packet4i>(const int* addr, const Packet4i& index)
 		{
@@ -869,7 +901,7 @@ namespace Eigen
 			return _mm_i32gather_epi32(addr, index, 4);
 #else
 			uint32_t u[4];
-			_mm_storeu_si128((Packet4i*)u, index);
+			_mm_storeu_si128((__m128i*)u, index);
 			return _mm_setr_epi32(addr[u[0]], addr[u[1]], addr[u[2]], addr[u[3]]);
 #endif
 		}
@@ -881,7 +913,7 @@ namespace Eigen
 			return _mm_i32gather_ps(addr, index, 4);
 #else
 			uint32_t u[4];
-			_mm_storeu_si128((Packet4i*)u, index);
+			_mm_storeu_si128((__m128i*)u, index);
 			return _mm_setr_ps(addr[u[0]], addr[u[1]], addr[u[2]], addr[u[3]]);
 #endif
 		}
@@ -893,7 +925,7 @@ namespace Eigen
 			return _mm_i32gather_pd(addr, index, 8);
 #else
 			uint32_t u[4];
-			_mm_storeu_si128((Packet4i*)u, index);
+			_mm_storeu_si128((__m128i*)u, index);
 			if (upperhalf)
 			{
 				return _mm_setr_pd(addr[u[2]], addr[u[3]]);
@@ -920,7 +952,7 @@ namespace Eigen
 		template<>
 		EIGEN_STRONG_INLINE int pmovemask<Packet4i>(const Packet4i& a)
 		{
-			return pmovemask(_mm_castsi128_ps(a));
+			return pmovemask((Packet4f)_mm_castsi128_ps(a));
 		}
 
 		template<>
@@ -958,7 +990,7 @@ namespace Eigen
 			return _mm_cmpeq_epi64(a, b);
 #else
 			Packet4i c = _mm_cmpeq_epi32(a, b);
-			return pand(c, _mm_shuffle_epi32(c, _MM_SHUFFLE(2, 3, 0, 1)));
+			return pand(c, (Packet4i)_mm_shuffle_epi32(c, _MM_SHUFFLE(2, 3, 0, 1)));
 #endif
 		}
 

data/vendor/EigenRand/EigenRand/MvDists/Multinomial.h

@@ -0,0 +1,222 @@
+/**
+ * @file Multinomial.h
+ * @author bab2min (bab2min@gmail.com)
+ * @brief
+ * @version 0.3.0
+ * @date 2020-10-07
+ *
+ * @copyright Copyright (c) 2020
+ *
+ */
+
+#ifndef EIGENRAND_MVDISTS_MULTINOMIAL_H
+#define EIGENRAND_MVDISTS_MULTINOMIAL_H
+
+namespace Eigen
+{
+	namespace Rand
+	{
+		/**
+		 * @brief Generator of real vectors on a multinomial distribution
+		 * 
+		 * @tparam _Scalar 
+		 * @tparam Dim number of dimensions, or `Eigen::Dynamic`
+		 */
+		template<typename _Scalar = int32_t, Index Dim = -1>
+		class MultinomialGen : public MvVecGenBase<MultinomialGen<_Scalar, Dim>, _Scalar, Dim>
+		{
+			static_assert(std::is_same<_Scalar, int32_t>::value, "`MultinomialGen` needs integral types.");
+			_Scalar trials;
+			Matrix<double, Dim, 1> probs;
+			DiscreteGen<_Scalar> discrete;
+		public:
+			/**
+			 * @brief Construct a new multinomial generator
+			 * 
+			 * @tparam WeightTy 
+			 * @param _trials the number of trials
+			 * @param _weights the weights of each category, `(Dim, 1)` shape matrix or vector
+			 */
+			template<typename WeightTy>
+			MultinomialGen(_Scalar _trials, const MatrixBase<WeightTy>& _weights)
+				: trials{ _trials }, probs{ _weights.template cast<double>() }, discrete(probs.data(), probs.data() + probs.size())
+			{
+				eigen_assert(_weights.cols() == 1);
+				for (Index i = 0; i < probs.size(); ++i)
+				{
+					eigen_assert(probs[i] >= 0);
+				}
+				probs /= probs.sum();
+			}
+
+			MultinomialGen(const MultinomialGen&) = default;
+			MultinomialGen(MultinomialGen&&) = default;
+
+			MultinomialGen& operator=(const MultinomialGen&) = default;
+			MultinomialGen& operator=(MultinomialGen&&) = default;
+
+			Index dims() const { return probs.rows(); }
+
+			template<typename Urng>
+			inline Matrix<_Scalar, Dim, -1> generate(Urng&& urng, Index samples)
+			{
+				const Index dim = probs.size();
+				Matrix<_Scalar, Dim, -1> ret(dim, samples);
+				//if (trials < 2500)
+				{
+					for (Index j = 0; j < samples; ++j)
+					{
+						ret.col(j) = generate(urng);
+					}
+				}
+				/*else
+				{
+					ret.row(0) = binomial<Matrix<_Scalar, -1, 1>>(samples, 1, urng, trials, probs[0]).eval().transpose();
+					for (Index j = 0; j < samples; ++j)
+					{
+						double rest_p = 1 - probs[0];
+						_Scalar t = trials - ret(0, j);
+						for (Index i = 1; i < dim - 1; ++i)
+						{
+							ret(i, j) = binomial<Matrix<_Scalar, 1, 1>>(1, 1, urng, t, probs[i] / rest_p)(0);
+							t -= ret(i, j);
+							rest_p -= probs[i];
+						}
+						ret(dim - 1, j) = 0;
+					}
+					ret.row(dim - 1).setZero();
+					ret.row(dim - 1).array() = trials - ret.colwise().sum().array();
+				}*/
+				return ret;
+			}
+
+			template<typename Urng>
+			inline Matrix<_Scalar, Dim, 1> generate(Urng&& urng)
+			{
+				const Index dim = probs.size();
+				Matrix<_Scalar, Dim, 1> ret(dim);
+				//if (trials < 2500)
+				{
+					ret.setZero();
+					auto d = discrete.template generate<Matrix<_Scalar, -1, 1>>(trials, 1, urng).eval();
+					for (Index i = 0; i < trials; ++i)
+					{
+						ret[d[i]] += 1;
+					}
+				}
+				/*else
+				{
+					double rest_p = 1;
+					_Scalar t = trials;
+					for (Index i = 0; i < dim - 1; ++i)
+					{
+						ret[i] = binomial<Matrix<_Scalar, 1, 1>>(1, 1, urng, t, probs[i] / rest_p)(0);
+						t -= ret[i];
+						rest_p -= probs[i];
+					}
+					ret[dim - 1] = 0;
+					ret[dim - 1] = trials - ret.sum();
+				}*/
+				return ret;
+			}
+		};
+
+		/**
+		 * @brief helper function constructing Eigen::Rand::MultinomialGen
+		 * 
+		 * @tparam IntTy 
+		 * @tparam WeightTy 
+		 * @param trials the number of trials
+		 * @param probs The weights of each category with shape `(Dim, 1)` of matrix or vector.
+		 * The number of entries determines the dimensionality of the distribution
+		 * @return an instance of MultinomialGen in the appropriate type
+		 */
+		template<typename IntTy, typename WeightTy>
+		inline auto makeMultinomialGen(IntTy trials, const MatrixBase<WeightTy>& probs)
+			-> MultinomialGen<IntTy, MatrixBase<WeightTy>::RowsAtCompileTime>
+		{
+			return MultinomialGen<IntTy, MatrixBase<WeightTy>::RowsAtCompileTime>{ trials, probs };
+		}
+
+		/**
+		 * @brief Generator of reals on a Dirichlet distribution
+		 * 
+		 * @tparam _Scalar 
+		 * @tparam Dim number of dimensions, or `Eigen::Dynamic`
+		 */
+		template<typename _Scalar, Index Dim = -1>
+		class DirichletGen : public MvVecGenBase<DirichletGen<_Scalar, Dim>, _Scalar, Dim>
+		{
+			Matrix<_Scalar, Dim, 1> alpha;
+			std::vector<GammaGen<_Scalar>> gammas;
+		public:
+			/**
+			 * @brief Construct a new Dirichlet generator
+			 * 
+			 * @tparam AlphaTy 
+			 * @param _alpha the concentration parameters with shape `(Dim, 1)` matrix or vector
+			 */
+			template<typename AlphaTy>
+			DirichletGen(const MatrixBase<AlphaTy>& _alpha)
+				: alpha{ _alpha }
+			{
+				eigen_assert(_alpha.cols() == 1);
+				for (Index i = 0; i < alpha.size(); ++i)
+				{
+					eigen_assert(alpha[i] > 0);
+					gammas.emplace_back(alpha[i]);
+				}
+			}
+
+			DirichletGen(const DirichletGen&) = default;
+			DirichletGen(DirichletGen&&) = default;
+
+			Index dims() const { return alpha.rows(); }
+
+			template<typename Urng>
+			inline Matrix<_Scalar, Dim, -1> generate(Urng&& urng, Index samples)
+			{
+				const Index dim = alpha.size();
+				Matrix<_Scalar, Dim, -1> ret(dim, samples);
+				Matrix<_Scalar, -1, 1> tmp(samples);
+				for (Index i = 0; i < dim; ++i)
+				{
+					tmp = gammas[i].generateLike(tmp, urng);
+					ret.row(i) = tmp.transpose();
+				}
+				ret.array().rowwise() /= ret.array().colwise().sum();
+				return ret;
+			}
+
+			template<typename Urng>
+			inline Matrix<_Scalar, Dim, 1> generate(Urng&& urng)
+			{
+				const Index dim = alpha.size();
+				Matrix<_Scalar, Dim, 1> ret(dim);
+				for (Index i = 0; i < dim; ++i)
+				{
+					ret[i] = gammas[i].template generate<Matrix<_Scalar, 1, 1>>(1, 1, urng)(0);
+				}
+				ret /= ret.sum();
+				return ret;
+			}
+		};
+
+		/**
+		 * @brief helper function constructing Eigen::Rand::DirichletGen
+		 * 
+		 * @tparam AlphaTy 
+		 * @param alpha The concentration parameters with shape `(Dim, 1)` of matrix or vector.
+		 * The number of entries determines the dimensionality of the distribution.
+		 * @return an instance of MultinomialGen in the appropriate type
+		 */
+		template<typename AlphaTy>
+		inline auto makeDirichletGen(const MatrixBase<AlphaTy>& alpha)
+			-> DirichletGen<typename MatrixBase<AlphaTy>::Scalar, MatrixBase<AlphaTy>::RowsAtCompileTime>
+		{
+			return DirichletGen<typename MatrixBase<AlphaTy>::Scalar, MatrixBase<AlphaTy>::RowsAtCompileTime>{ alpha };
+		}
+	}
+}
+
+#endif