tomoto 0.6.0 → 0.6.2

data/vendor/EigenRand/EigenRand/Macro.h

@@ -2,8 +2,8 @@
  * @file Macro.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.4.1
- * @date 2022-08-13
+ * @version 0.5.1
+ * @date 2024-09-08
  * 
  * @copyright Copyright (c) 2020-2021
  * 
@@ -13,7 +13,7 @@
 #define EIGENRAND_MACRO_H
 
 #define EIGENRAND_WORLD_VERSION 0
-#define EIGENRAND_MAJOR_VERSION 4
+#define EIGENRAND_MAJOR_VERSION 5
 #define EIGENRAND_MINOR_VERSION 1
 
 #if EIGEN_VERSION_AT_LEAST(3,3,10)

data/vendor/EigenRand/EigenRand/MorePacketMath.h

@@ -2,10 +2,10 @@
  * @file MorePacketMath.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.4.1
- * @date 2022-08-13
- * 
- * @copyright Copyright (c) 2020-2021
+ * @version 0.5.1
+ * @date 2024-09-08
+ *
+ * @copyright Copyright (c) 2020-2024
  * 
  */
 
@@ -13,6 +13,7 @@
 #define EIGENRAND_MORE_PACKET_MATH_H
 
 #include <Eigen/Dense>
+#include <cstdint>
 
 #define EIGENRAND_PRINT_PACKET(p) do { using _MTy = typename std::remove_const<typename std::remove_reference<decltype(p)>::type>::type; typename std::conditional<Eigen::internal::IsFloatPacket<_MTy>::value, float, typename std::conditional<Eigen::internal::IsDoublePacket<_MTy>::value, double, int>::type>::type f[4]; Eigen::internal::pstore(f, p); std::cout << #p " " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << std::endl; } while(0)
 
@@ -89,6 +90,12 @@ namespace Eigen
 		template<int b, typename Packet>
 		EIGEN_STRONG_INLINE Packet psrl64(const Packet& a);
 
+		template<typename Packet> 
+		EIGEN_STRONG_INLINE bool predux_all(const Packet& a);
+
+		template<typename Packet>
+		EIGEN_STRONG_INLINE bool predux_any(const Packet& a);
+
 		/*template<typename Packet>
 		EIGEN_STRONG_INLINE Packet psll(const Packet& a, int b);
 
@@ -209,6 +216,16 @@ namespace Eigen
 			return psub(reinterpret_to_double(por(pand(x, lower), upper)), one);
 		}
 
+		template<typename Packet>
+		EIGEN_STRONG_INLINE Packet pnew_andnot(const Packet& a, const Packet& b)
+		{
+#if defined(EIGEN_VECTORIZE_NEON) || defined(EIGENRAND_EIGEN_34_MODE)
+			return pandnot(a, b);
+#else
+			return pandnot(b, a);
+#endif
+		}
+
 		template<typename _Scalar>
 		struct BitScalar;
 
@@ -319,11 +336,7 @@ namespace Eigen
 			x = padd(x, xmm3);
 
 			emm4 = psub(emm4, pset1<IntPacket>(2));
-	#if defined(EIGEN_VECTORIZE_NEON) || defined(EIGENRAND_EIGEN_34_MODE)
-			emm4 = pandnot(pset1<IntPacket>(4), emm4);
-	#else
-			emm4 = pandnot(emm4, pset1<IntPacket>(4));
-	#endif
+			emm4 = pnew_andnot(pset1<IntPacket>(4), emm4);
 			emm4 = psll<29>(emm4);
 			Packet sign_bit_cos = reinterpret_to_float(emm4);
 			sign_bit_sin = pxor(sign_bit_sin, swap_sign_bit_sin);
@@ -357,11 +370,7 @@ namespace Eigen
 			/* select the correct result from the two polynoms */
 			xmm3 = poly_mask;
 			Packet ysin2 = pand(xmm3, y2);
-	#if defined(EIGEN_VECTORIZE_NEON) || defined(EIGENRAND_EIGEN_34_MODE)
-			Packet ysin1 = pandnot(y, xmm3);
-	#else
-			Packet ysin1 = pandnot(xmm3, y);
-	#endif
+			Packet ysin1 = pnew_andnot(y, xmm3);
 			y2 = psub(y2, ysin2);
 			y = psub(y, ysin1);
 
@@ -425,11 +434,7 @@ namespace Eigen
 			x = padd(x, xmm3);
 
 			emm4 = psub64(emm4, pseti64<IntPacket>(2));
-	#if defined(EIGEN_VECTORIZE_NEON) || defined(EIGENRAND_EIGEN_34_MODE)
-			emm4 = pandnot(pseti64<IntPacket>(4), emm4);
-	#else
-			emm4 = pandnot(emm4, pseti64<IntPacket>(4));
-	#endif
+			emm4 = pnew_andnot(pseti64<IntPacket>(4), emm4);
 			emm4 = psll64<61>(emm4);
 			Packet sign_bit_cos = reinterpret_to_double(emm4);
 			sign_bit_sin = pxor(sign_bit_sin, swap_sign_bit_sin);
@@ -463,11 +468,7 @@ namespace Eigen
 			/* select the correct result from the two polynoms */
 			xmm3 = poly_mask;
 			Packet ysin2 = pand(xmm3, y2);
-	#if defined(EIGEN_VECTORIZE_NEON) || defined(EIGENRAND_EIGEN_34_MODE)
-			Packet ysin1 = pandnot(y, xmm3);
-	#else
-			Packet ysin1 = pandnot(xmm3, y);
-	#endif
+			Packet ysin1 = pnew_andnot(y, xmm3);
 			y2 = psub(y2, ysin2);
 			y = psub(y, ysin1);
 
@@ -559,11 +560,7 @@ namespace Eigen
 			/* select the correct result from the two polynoms */
 			xmm3 = poly_mask;
 			Packet ysin2 = pand(xmm3, y2);
-	#if defined(EIGEN_VECTORIZE_NEON) || defined(EIGENRAND_EIGEN_34_MODE)
-			Packet ysin1 = pandnot(y, xmm3);
-	#else
-			Packet ysin1 = pandnot(xmm3, y);
-	#endif
+			Packet ysin1 = pnew_andnot(y, xmm3);
 
 			xmm1 = padd(ysin1, ysin2);
 
@@ -573,6 +570,10 @@ namespace Eigen
 	}
 }
 
+#ifdef EIGEN_VECTORIZE_AVX512
+#include "arch/AVX512/MorePacketMath.h"
+#endif
+
 #ifdef EIGEN_VECTORIZE_AVX
 #include "arch/AVX/MorePacketMath.h"
 #endif
@@ -615,4 +616,4 @@ namespace Eigen
 	}
 }
 
-#endif
+#endif

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

@@ -2,10 +2,10 @@
  * @file Multinomial.h
  * @author bab2min (bab2min@gmail.com)
  * @brief
- * @version 0.4.1
- * @date 2022-08-13
+ * @version 0.5.1
+ * @date 2024-09-08
  *
- * @copyright Copyright (c) 2020-2021
+ * @copyright Copyright (c) 2020-2024
  *
  */
 
@@ -28,7 +28,7 @@ namespace Eigen
 			static_assert(std::is_same<_Scalar, int32_t>::value, "`MultinomialGen` needs integral types.");
 			_Scalar trials;
 			Matrix<double, Dim, 1> probs;
-			DiscreteGen<_Scalar> discrete;
+			DiscreteGen<_Scalar, int32_t> discrete;
 		public:
 			/**
 			 * @brief Construct a new multinomial generator
@@ -62,31 +62,33 @@ namespace Eigen
 			{
 				const Index dim = probs.size();
 				Matrix<_Scalar, Dim, -1> ret(dim, samples);
-				//if (trials < 2500)
+				if (trials < std::max(30 * (dim - 1), (Index)100))
 				{
-					for (Index j = 0; j < samples; ++j)
+					for (Index s = 0; s < samples; ++s)
 					{
-						ret.col(j) = generate(urng);
+						ret.col(s) = generate(urng);
 					}
 				}
-				/*else
+				else
 				{
-					ret.row(0) = binomial<Matrix<_Scalar, -1, 1>>(samples, 1, urng, trials, probs[0]).eval().transpose();
-					for (Index j = 0; j < samples; ++j)
+					Array<_Scalar, 1, -1> r_trials{ samples }, t{ samples };
+					Map<const Array<float, -1, 1>> fr_trials{ reinterpret_cast<float*>(r_trials.data()), samples };
+					Map<Array<float, -1, 1>> ft{ reinterpret_cast<float*>(t.data()), samples };
+					r_trials.setConstant(trials);
+					ft = impl::binomial(urng, fr_trials, probs[0]);
+					r_trials -= t;
+					ret.row(0) = t.matrix();
+					double rest_p = 1 - probs[0];
+					for (Index i = 1; i < dim - 1; ++i)
 					{
-						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;
+						ft = impl::binomial(urng, fr_trials, probs[i] / rest_p);
+						r_trials -= t;
+						ret.row(i) = t.matrix();
+						rest_p -= probs[i];
 					}
-					ret.row(dim - 1).setZero();
-					ret.row(dim - 1).array() = trials - ret.colwise().sum().array();
-				}*/
+
+					ret.row(dim - 1) = r_trials;
+				}
 				return ret;
 			}
 
@@ -95,13 +97,24 @@ namespace Eigen
 			{
 				const Index dim = probs.size();
 				Matrix<_Scalar, Dim, 1> ret(dim);
-				//if (trials < 2500)
+				//if (trials < std::max(30 * (dim - 1), (Index)100))
 				{
 					ret.setZero();
-					auto d = discrete.template generate<Matrix<_Scalar, -1, 1>>(trials, 1, urng).eval();
-					for (Index i = 0; i < trials; ++i)
+					auto d = discrete.template generate<Matrix<_Scalar, 16, 1>>(16, 1, urng);
+					Matrix<_Scalar, 16, 1> buf;
+					Index i;
+					for (i = 0; i < (trials & ~15); i += 16)
+					{
+						buf = d;
+						for (Index j = 0; j < 16; ++j)
+						{
+							ret[buf[j]] += 1;
+						}
+					}
+					buf.middleRows(0, trials - i) = d.middleRows(0, trials - i);
+					for (Index j = 0; j < trials - i; ++j)
 					{
-						ret[d[i]] += 1;
+						ret[buf[j]] += 1;
 					}
 				}
 				/*else
@@ -110,12 +123,11 @@ namespace Eigen
 					_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);
+						ret[i] = binomial<Array<_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();
+					ret[dim - 1] = trials - ret.head(dim - 1).sum();
 				}*/
 				return ret;
 			}

data/vendor/EigenRand/EigenRand/MvDists/MvNormal.h

@@ -2,10 +2,10 @@
  * @file MvNormal.h
  * @author bab2min (bab2min@gmail.com)
  * @brief
- * @version 0.4.1
- * @date 2022-08-13
+ * @version 0.5.1
+ * @date 2024-09-08
  *
- * @copyright Copyright (c) 2020-2021
+ * @copyright Copyright (c) 2020-2024
  *
  */
 
@@ -115,6 +115,20 @@ namespace Eigen
 			}
 		};
 
+    namespace detail {
+      template<typename MeanTy, typename CovTy>
+      constexpr bool either_is_dynamic() {
+        return (MatrixBase<MeanTy>::RowsAtCompileTime == Eigen::Dynamic) ||
+                (MatrixBase<CovTy>::RowsAtCompileTime == Eigen::Dynamic);
+      }
+
+      template<typename MeanTy, typename CovTy>
+      constexpr bool normal_check_dims() {
+        return (either_is_dynamic<MeanTy, CovTy>() || MatrixBase<MeanTy>::RowsAtCompileTime == MatrixBase<CovTy>::RowsAtCompileTime) &&
+               MatrixBase<CovTy>::RowsAtCompileTime == MatrixBase<CovTy>::ColsAtCompileTime;
+      }
+    }
+
 		/**
 		 * @brief helper function constructing Eigen::Rand::MvNormal
 		 * 
@@ -132,8 +146,7 @@ namespace Eigen
 				"Derived::Scalar must be the same with `mean` and `cov`'s Scalar."
 			);
 			static_assert(
-				MatrixBase<MeanTy>::RowsAtCompileTime == MatrixBase<CovTy>::RowsAtCompileTime &&
-				MatrixBase<CovTy>::RowsAtCompileTime == MatrixBase<CovTy>::ColsAtCompileTime,
+        detail::normal_check_dims<MeanTy, CovTy>(),
 				"assert: mean.RowsAtCompileTime == cov.RowsAtCompileTime && cov.RowsAtCompileTime == cov.ColsAtCompileTime"
 			);
 			return { mean, cov };
@@ -156,8 +169,7 @@ namespace Eigen
 				"Derived::Scalar must be the same with `mean` and `lt`'s Scalar."
 			);
 			static_assert(
-				MatrixBase<MeanTy>::RowsAtCompileTime == MatrixBase<LTTy>::RowsAtCompileTime &&
-				MatrixBase<LTTy>::RowsAtCompileTime == MatrixBase<LTTy>::ColsAtCompileTime,
+        detail::normal_check_dims<MeanTy, LTTy>(),
 				"assert: mean.RowsAtCompileTime == lt.RowsAtCompileTime && lt.RowsAtCompileTime == lt.ColsAtCompileTime"
 			);
 			return { mean, lt, lower_triangular };

data/vendor/EigenRand/EigenRand/PacketFilter.h

@@ -2,10 +2,10 @@
  * @file PacketFilter.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.4.1
- * @date 2022-08-13
- * 
- * @copyright Copyright (c) 2020-2021
+ * @version 0.5.1
+ * @date 2024-09-08
+ *
+ * @copyright Copyright (c) 2020-2024
  * 
  */
 
@@ -27,6 +27,9 @@ namespace Eigen
 	}
 }
 
+#ifdef EIGEN_VECTORIZE_AVX512
+#include "arch/AVX512/PacketFilter.h"
+#endif
 
 #ifdef EIGEN_VECTORIZE_AVX
 #include "arch/AVX/PacketFilter.h"
@@ -41,4 +44,4 @@ namespace Eigen
 #endif
 
 
-#endif
+#endif

data/vendor/EigenRand/EigenRand/PacketRandomEngine.h

@@ -2,10 +2,10 @@
  * @file PacketRandomEngine.h
  * @author bab2min (bab2min@gmail.com)
  * @brief
- * @version 0.4.1
- * @date 2022-08-13
+ * @version 0.5.1
+ * @date 2024-09-08
  *
- * @copyright Copyright (c) 2020-2021
+ * @copyright Copyright (c) 2020-2024
  *
  */
 

data/vendor/EigenRand/EigenRand/RandUtils.h

@@ -2,10 +2,10 @@
  * @file RandUtils.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.4.1
- * @date 2022-08-13
- * 
- * @copyright Copyright (c) 2020-2021
+ * @version 0.5.1
+ * @date 2024-09-08
+ *
+ * @copyright Copyright (c) 2020-2024
  * 
  */
 
@@ -134,11 +134,186 @@ namespace Eigen
 		template<typename Gen, typename _Scalar, typename Urng, bool _mutable>
 		struct functor_traits<scalar_rng_adaptor<Gen, _Scalar, Urng, _mutable> >
 		{
-			enum { Cost = HugeCost, PacketAccess = packet_traits<_Scalar>::Vectorizable, IsRepeatable = false };
+			enum { Cost = HugeCost, PacketAccess = std::is_floating_point<_Scalar>::value ? packet_traits<_Scalar>::HasExp : packet_traits<_Scalar>::Vectorizable, IsRepeatable = false };
+		};
+
+		template<typename Gen, typename _Scalar, typename _ScalarA, typename Rng, bool _mutable = false>
+		struct scalar_unary_rng_adaptor
+		{
+			static_assert(
+				Rand::IsScalarFullBitRandomEngine<
+				typename std::remove_reference<Rng>::type
+				>::value ||
+				Rand::IsPacketRandomEngine<
+				typename std::remove_reference<Rng>::type
+				>::value,
+				"Rng must satisfy RandomNumberEngine"
+				);
+
+			Gen gen;
+			Rng rng;
+
+			scalar_unary_rng_adaptor(const Rng& _rng) : rng{ _rng }
+			{
+			}
+
+			template<typename _Gen>
+			scalar_unary_rng_adaptor(const Rng& _rng, _Gen&& _gen) : gen{ _gen }, rng{ _rng }
+			{
+			}
+
+			scalar_unary_rng_adaptor(const scalar_unary_rng_adaptor& o) = default;
+			scalar_unary_rng_adaptor(scalar_unary_rng_adaptor&& o) = default;
+
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const _Scalar operator() (_ScalarA a) const
+			{
+				return gen(rng, a);
+			}
+
+			template<typename Packet>
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+			{
+				return gen.template packetOp<Packet>(rng, a);
+			}
+		};
+
+		template<typename Gen, typename _Scalar, typename _ScalarA, typename Rng>
+		struct scalar_unary_rng_adaptor<Gen, _Scalar, _ScalarA, Rng, true>
+		{
+			static_assert(
+				Rand::IsScalarFullBitRandomEngine<
+				typename std::remove_reference<Rng>::type
+				>::value ||
+				Rand::IsPacketRandomEngine<
+				typename std::remove_reference<Rng>::type
+				>::value,
+				"Rng must satisfy RandomNumberEngine"
+				);
+
+			mutable Gen gen;
+			Rng rng;
+
+			scalar_unary_rng_adaptor(const Rng& _rng) : rng{ _rng }
+			{
+			}
+
+			template<typename _Gen>
+			scalar_unary_rng_adaptor(const Rng& _rng, _Gen&& _gen) : gen{ _gen }, rng{ _rng }
+			{
+			}
+
+			scalar_unary_rng_adaptor(const scalar_unary_rng_adaptor& o) = default;
+			scalar_unary_rng_adaptor(scalar_unary_rng_adaptor&& o) = default;
+
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const _Scalar operator() (_ScalarA a) const
+			{
+				return gen(rng, a);
+			}
+
+			template<typename Packet>
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+			{
+				return gen.template packetOp<Packet>(rng, a);
+			}
+		};
+
+		template<typename Gen, typename _Scalar, typename _ScalarA, typename Urng, bool _mutable>
+		struct functor_traits<scalar_unary_rng_adaptor<Gen, _Scalar, _ScalarA, Urng, _mutable> >
+		{
+			enum { Cost = HugeCost, PacketAccess = std::is_floating_point<_Scalar>::value ? packet_traits<_Scalar>::HasExp : packet_traits<_Scalar>::Vectorizable, IsRepeatable = false };
+		};
+
+		template<typename Gen, typename _Scalar, typename _ScalarA, typename _ScalarB, typename Rng, bool _mutable = false>
+		struct scalar_binary_rng_adaptor
+		{
+			static_assert(
+				Rand::IsScalarFullBitRandomEngine<
+				typename std::remove_reference<Rng>::type
+				>::value ||
+				Rand::IsPacketRandomEngine<
+				typename std::remove_reference<Rng>::type
+				>::value,
+				"Rng must satisfy RandomNumberEngine"
+				);
+
+			Gen gen;
+			Rng rng;
+
+			scalar_binary_rng_adaptor(const Rng& _rng) : rng{ _rng }
+			{
+			}
+
+			template<typename _Gen>
+			scalar_binary_rng_adaptor(const Rng& _rng, _Gen&& _gen) : gen{ _gen }, rng{ _rng }
+			{
+			}
+
+			scalar_binary_rng_adaptor(const scalar_binary_rng_adaptor& o) = default;
+			scalar_binary_rng_adaptor(scalar_binary_rng_adaptor&& o) = default;
+
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const _Scalar operator() (_ScalarA a, _ScalarB b) const
+			{
+				return gen(rng, a, b);
+			}
+
+			template<typename Packet>
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+			{
+				return gen.template packetOp<Packet>(rng, a, b);
+			}
+		};
+
+		template<typename Gen, typename _Scalar, typename _ScalarA, typename _ScalarB, typename Rng>
+		struct scalar_binary_rng_adaptor<Gen, _Scalar, _ScalarA, _ScalarB, Rng, true>
+		{
+			static_assert(
+				Rand::IsScalarFullBitRandomEngine<
+				typename std::remove_reference<Rng>::type
+				>::value ||
+				Rand::IsPacketRandomEngine<
+				typename std::remove_reference<Rng>::type
+				>::value,
+				"Rng must satisfy RandomNumberEngine"
+				);
+
+			mutable Gen gen;
+			Rng rng;
+
+			scalar_binary_rng_adaptor(const Rng& _rng) : rng{ _rng }
+			{
+			}
+
+			template<typename _Gen>
+			scalar_binary_rng_adaptor(const Rng& _rng, _Gen&& _gen) : gen{ _gen }, rng{ _rng }
+			{
+			}
+
+			scalar_binary_rng_adaptor(const scalar_binary_rng_adaptor& o) = default;
+			scalar_binary_rng_adaptor(scalar_binary_rng_adaptor&& o) = default;
+
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const _Scalar operator() (_ScalarA a, _ScalarB b) const
+			{
+				return gen(rng, a, b);
+			}
+
+			template<typename PacketA, typename PacketB>
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const PacketA packetOp(const PacketA& a, const PacketB& b) const
+			{
+				return gen.packetOp(rng, a, b);
+			}
+		};
+
+		template<typename Gen, typename _Scalar, typename _ScalarA, typename _ScalarB, typename Urng, bool _mutable>
+		struct functor_traits<scalar_binary_rng_adaptor<Gen, _Scalar, _ScalarA, _ScalarB, Urng, _mutable> >
+		{
+			enum { Cost = HugeCost, PacketAccess = std::is_floating_point<_Scalar>::value ? packet_traits<_Scalar>::HasExp : packet_traits<_Scalar>::Vectorizable, IsRepeatable = false };
 		};
 	}
 }
 
+#ifdef EIGEN_VECTORIZE_AVX512
+#include "arch/AVX512/RandUtils.h"
+#endif
 
 #ifdef EIGEN_VECTORIZE_AVX
 #include "arch/AVX/RandUtils.h"

data/vendor/EigenRand/EigenRand/arch/AVX/MorePacketMath.h

@@ -2,10 +2,10 @@
  * @file MorePacketMath.h
  * @author bab2min (bab2min@gmail.com)
  * @brief
- * @version 0.4.1
- * @date 2022-08-13
+ * @version 0.5.1
+ * @date 2024-09-08
  *
- * @copyright Copyright (c) 2020-2021
+ * @copyright Copyright (c) 2020-2024
  *
  */
 
@@ -176,6 +176,24 @@ namespace Eigen
 #endif
 		}
 
+		template<>
+		EIGEN_STRONG_INLINE Packet8f pcmpeq<Packet8f>(const Packet8f& a, const Packet8f& b)
+		{
+			return _mm256_cmp_ps(a, b, _CMP_EQ_OQ);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet8i pnegate<Packet8i>(const Packet8i& a)
+		{
+#ifdef EIGEN_VECTORIZE_AVX2
+			return _mm256_sub_epi32(pset1<Packet8i>(0), a);
+#else
+			Packet4i a1, a2;
+			split_two(a, a1, a2);
+			return combine_two(_mm_sub_epi32(pset1<Packet4i>(0), a1), _mm_sub_epi32(pset1<Packet4i>(0), a2));
+#endif
+		}
+
 		template<>
 		struct BitShifter<Packet8i>
 		{
@@ -301,7 +319,28 @@ namespace Eigen
 			return reinterpret_to_int((Packet8f)_mm256_xor_ps(reinterpret_to_float(a), reinterpret_to_float(b)));
 	#endif
 		}
+
+		template<> EIGEN_STRONG_INLINE bool predux_any(const Packet8f& x)
+		{
+			return !!_mm256_movemask_ps(x);
+		}
+
+		template<> EIGEN_STRONG_INLINE bool predux_any(const Packet8i& x)
+		{
+			return predux_any(_mm256_castsi256_ps(x));
+		}
 #endif
+
+		template<> EIGEN_STRONG_INLINE bool predux_all(const Packet8f& x)
+		{
+			return _mm256_movemask_ps(x) == 0xFF;
+		}
+
+		template<> EIGEN_STRONG_INLINE bool predux_all(const Packet8i& x)
+		{
+			return predux_all(_mm256_castsi256_ps(x));
+		}
+
 		template<>
 		EIGEN_STRONG_INLINE Packet8i pcmplt<Packet8i>(const Packet8i& a, const Packet8i& b)
 		{

data/vendor/EigenRand/EigenRand/arch/AVX/PacketFilter.h

@@ -2,10 +2,10 @@
  * @file PacketFilter.h
  * @author bab2min (bab2min@gmail.com)
  * @brief
- * @version 0.4.1
- * @date 2022-08-13
+ * @version 0.5.1
+ * @date 2024-09-08
  *
- * @copyright Copyright (c) 2020-2021
+ * @copyright Copyright (c) 2020-2024
  *
  */
 

data/vendor/EigenRand/EigenRand/arch/AVX/RandUtils.h

@@ -2,10 +2,10 @@
  * @file RandUtils.h
  * @author bab2min (bab2min@gmail.com)
  * @brief
- * @version 0.4.1
- * @date 2022-08-13
+ * @version 0.5.1
+ * @date 2024-09-08
  *
- * @copyright Copyright (c) 2020-2021
+ * @copyright Copyright (c) 2020-2024
  *
  */