tomoto 0.6.0 → 0.6.2

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

@@ -0,0 +1,312 @@
+/**
+ * @file MorePacketMath.h
+ * @author bab2min (bab2min@gmail.com)
+ * @brief
+ * @version 0.5.1
+ * @date 2024-09-08
+ *
+ * @copyright Copyright (c) 2020-2024
+ *
+ */
+
+#ifndef EIGENRAND_MORE_PACKET_MATH_AVX512_H
+#define EIGENRAND_MORE_PACKET_MATH_AVX512_H
+
+#include <immintrin.h>
+
+namespace Eigen
+{
+	namespace internal
+	{
+		template<>
+		struct IsIntPacket<Packet16i> : std::true_type {};
+
+		template<>
+		struct HalfPacket<Packet16i>
+		{
+			using type = Packet8i;
+		};
+
+		template<>
+		struct HalfPacket<Packet16f>
+		{
+			using type = Packet8f;
+		};
+
+		template<>
+		struct IsFloatPacket<Packet16f> : std::true_type {};
+
+		template<>
+		struct IsDoublePacket<Packet8d> : std::true_type {};
+
+		template<>
+		struct reinterpreter<Packet16i>
+		{
+			EIGEN_STRONG_INLINE Packet16f to_float(const Packet16i& x)
+			{
+				return _mm512_castsi512_ps(x);
+			}
+
+			EIGEN_STRONG_INLINE Packet8d to_double(const Packet16i& x)
+			{
+				return _mm512_castsi512_pd(x);
+			}
+
+			EIGEN_STRONG_INLINE Packet16i to_int(const Packet16i& x)
+			{
+				return x;
+			}
+		};
+
+		template<>
+		struct reinterpreter<Packet16f>
+		{
+			EIGEN_STRONG_INLINE Packet16f to_float(const Packet16f& x)
+			{
+				return x;
+			}
+
+			EIGEN_STRONG_INLINE Packet8d to_double(const Packet16f& x)
+			{
+				return _mm512_castps_pd(x);
+			}
+
+			EIGEN_STRONG_INLINE Packet16i to_int(const Packet16f& x)
+			{
+				return _mm512_castps_si512(x);
+			}
+		};
+
+		template<>
+		struct reinterpreter<Packet8d>
+		{
+			EIGEN_STRONG_INLINE Packet16f to_float(const Packet8d& x)
+			{
+				return _mm512_castpd_ps(x);
+			}
+
+			EIGEN_STRONG_INLINE Packet8d to_double(const Packet8d& x)
+			{
+				return x;
+			}
+
+			EIGEN_STRONG_INLINE Packet16i to_int(const Packet8d& x)
+			{
+				return _mm512_castpd_si512(x);
+			}
+		};
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16i pseti64<Packet16i>(uint64_t a)
+		{
+			return _mm512_set1_epi64(a);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16i padd64<Packet16i>(const Packet16i& a, const Packet16i& b)
+		{
+			return _mm512_add_epi64(a, b);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16i psub64<Packet16i>(const Packet16i& a, const Packet16i& b)
+		{
+			return _mm512_sub_epi64(a, b);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16i pcmpeq<Packet16i>(const Packet16i& a, const Packet16i& b)
+		{
+			return pcmp_eq(a, b);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16f pcmpeq<Packet16f>(const Packet16f& a, const Packet16f& b)
+		{
+			return pcmp_eq(a, b);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16i pnegate<Packet16i>(const Packet16i& a)
+		{
+			return _mm512_sub_epi32(pset1<Packet16i>(0), a);
+		}
+
+		template<>
+		struct BitShifter<Packet16i>
+		{
+			template<int b>
+			EIGEN_STRONG_INLINE Packet16i sll(const Packet16i& a)
+			{
+				return _mm512_slli_epi32(a, b);
+			}
+
+			template<int b>
+			EIGEN_STRONG_INLINE Packet16i srl(const Packet16i& a, int _b = b)
+			{
+				if (b >= 0)
+				{
+					return _mm512_srli_epi32(a, b);
+				}
+				else
+				{
+					return _mm512_srli_epi32(a, _b);
+				}
+			}
+
+			template<int b>
+			EIGEN_STRONG_INLINE Packet16i sll64(const Packet16i& a)
+			{
+				return _mm512_slli_epi64(a, b);
+			}
+
+			template<int b>
+			EIGEN_STRONG_INLINE Packet16i srl64(const Packet16i& a)
+			{
+				return _mm512_srli_epi64(a, b);
+			}
+		};
+
+		template<> EIGEN_STRONG_INLINE bool predux_all(const Packet16i& x)
+		{
+			return _mm512_movepi32_mask(x) == 0xFFFF;
+		}
+
+		template<> EIGEN_STRONG_INLINE bool predux_all(const Packet16f& x)
+		{
+			return predux_all(_mm512_castps_si512(x));
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16i pcmplt<Packet16i>(const Packet16i& a, const Packet16i& b)
+		{
+			__mmask16 mask = _mm512_cmp_epi32_mask(a, b, _MM_CMPINT_LT);
+			return _mm512_movm_epi32(mask);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16f pcmplt<Packet16f>(const Packet16f& a, const Packet16f& b)
+		{
+			return pcmp_lt(a, b);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16f pcmple<Packet16f>(const Packet16f& a, const Packet16f& b)
+		{
+			return pcmp_le(a, b);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet8d pcmplt<Packet8d>(const Packet8d& a, const Packet8d& b)
+		{
+			return pcmp_lt(a, b);
+		}
+		template<>
+		EIGEN_STRONG_INLINE Packet8d pcmple<Packet8d>(const Packet8d& a, const Packet8d& b)
+		{
+			return pcmp_le(a, b);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16f pblendv(const Packet16i& ifPacket, const Packet16f& thenPacket, const Packet16f& elsePacket)
+		{
+			__mmask16 mask = _mm512_movepi32_mask(ifPacket);
+			return _mm512_mask_blend_ps(mask, elsePacket, thenPacket);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16f pblendv(const Packet16f& ifPacket, const Packet16f& thenPacket, const Packet16f& elsePacket)
+		{
+			return pblendv(_mm512_castps_si512(ifPacket), thenPacket, elsePacket);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16i pblendv(const Packet16i& ifPacket, const Packet16i& thenPacket, const Packet16i& elsePacket)
+		{
+			__mmask16 mask = _mm512_movepi32_mask(ifPacket);
+			return _mm512_mask_blend_epi32(mask, elsePacket, thenPacket);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet8d pblendv(const Packet16i& ifPacket, const Packet8d& thenPacket, const Packet8d& elsePacket)
+		{
+			__mmask8 mask = _mm512_movepi64_mask(ifPacket);
+			return _mm512_mask_blend_pd(mask, elsePacket, thenPacket);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet8d pblendv(const Packet8d& ifPacket, const Packet8d& thenPacket, const Packet8d& elsePacket)
+		{
+			return pblendv(_mm512_castpd_si512(ifPacket), thenPacket, elsePacket);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16i pgather<Packet16i>(const int* addr, const Packet16i& index)
+		{
+			return _mm512_i32gather_epi32(index, addr, 4);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16f pgather<Packet16i>(const float* addr, const Packet16i& index)
+		{
+			return _mm512_i32gather_ps(index, addr, 4);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet8d pgather<Packet16i>(const double* addr, const Packet16i& index, bool upperhalf)
+		{
+			return _mm512_i32gather_pd(_mm512_castsi512_si256(index), addr, 8);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16f ptruncate<Packet16f>(const Packet16f& a)
+		{
+			return _mm512_roundscale_ps(a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet8d ptruncate<Packet8d>(const Packet8d& a)
+		{
+			return _mm512_roundscale_pd(a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet16i pcmpeq64<Packet16i>(const Packet16i& a, const Packet16i& b)
+		{
+			__mmask8 mask = _mm512_cmp_epi64_mask(a, b, _MM_CMPINT_EQ);
+			return _mm512_movm_epi64(mask);
+		}
+
+		EIGEN_STRONG_INLINE __m512d int64_to_double_avx512(__m512i x) {
+			x = padd64(x, _mm512_castpd_si512(_mm512_set1_pd(0x0018000000000000)));
+			return _mm512_sub_pd(_mm512_castsi512_pd(x), _mm512_set1_pd(0x0018000000000000));
+		}
+
+		EIGEN_STRONG_INLINE __m512i double_to_int64_avx512(__m512d x) {
+			x = _mm512_add_pd(_mm512_floor_pd(x), _mm512_set1_pd(0x0018000000000000));
+			return psub64(
+				_mm512_castpd_si512(x),
+				_mm512_castpd_si512(_mm512_set1_pd(0x0018000000000000))
+			);
+		}
+		template<>
+		EIGEN_STRONG_INLINE Packet16i pcast64<Packet8d, Packet16i>(const Packet8d& a)
+		{
+			return double_to_int64_avx512(a);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet8d pcast64<Packet16i, Packet8d>(const Packet16i& a)
+		{
+			return int64_to_double_avx512(a);
+		}
+
+		template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+			Packet8d psin<Packet8d>(const Packet8d& x)
+		{
+			return _psin(x);
+		}
+	}
+}
+
+#endif

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

@@ -0,0 +1,79 @@
+/**
+ * @file PacketFilter.h
+ * @author bab2min (bab2min@gmail.com)
+ * @brief
+ * @version 0.5.1
+ * @date 2024-09-08
+ *
+ * @copyright Copyright (c) 2020-2024
+ *
+ */
+
+#ifndef EIGENRAND_PACKET_FILTER_AVX512_H
+#define EIGENRAND_PACKET_FILTER_AVX512_H
+
+#include <immintrin.h>
+
+namespace Eigen
+{
+	namespace Rand
+	{
+		namespace detail
+		{
+			template<>
+			class CompressMask<64>
+			{
+				CompressMask() {}
+
+			public:
+				enum { full_size = 16 };
+				static const CompressMask& get_inst()
+				{
+					static CompressMask cm;
+					return cm;
+				}
+
+				template<typename Packet>
+				EIGEN_STRONG_INLINE int compress_append(Packet& _value, const Packet& _mask,
+					Packet& _rest, int rest_cnt, bool& full) const
+				{
+					auto& value = reinterpret_cast<internal::Packet16f&>(_value);
+					auto& mask = reinterpret_cast<const internal::Packet16f&>(_mask);
+					auto& rest = reinterpret_cast<internal::Packet16f&>(_rest);
+
+					const __mmask16 m = _mm512_movepi32_mask(_mm512_castps_si512(mask));
+
+					if (m == 0xFFFF)
+					{
+						full = true;
+						return rest_cnt;
+					}
+
+					const int cnt_m = _mm_popcnt_u32(m);
+
+					const __m512i counting = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+					__m512i rotate = _mm512_sub_epi32(counting, _mm512_set1_epi32(cnt_m));
+					__m512 rot_rest = _mm512_permutexvar_ps(rotate, rest);
+
+					__m512 p1 = _mm512_mask_compress_ps(rot_rest, m, value);
+
+					auto new_cnt = rest_cnt + cnt_m;
+					if (new_cnt >= full_size)
+					{
+						rest = rot_rest;
+						value = p1;
+						full = true;
+						return new_cnt - full_size;
+					}
+					else
+					{
+						rest = p1;
+						full = false;
+						return new_cnt;
+					}
+				}
+			};
+		}
+	}
+}
+#endif

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

@@ -0,0 +1,147 @@
+/**
+ * @file RandUtils.h
+ * @author bab2min (bab2min@gmail.com)
+ * @brief
+ * @version 0.5.1
+ * @date 2024-09-08
+ *
+ * @copyright Copyright (c) 2020-2024
+ *
+ */
+
+#ifndef EIGENRAND_RAND_UTILS_AVX512_H
+#define EIGENRAND_RAND_UTILS_AVX512_H
+
+#include <immintrin.h>
+
+namespace Eigen
+{
+	namespace internal
+	{
+		template<typename Rng>
+		struct RawbitsMaker<Packet8i, Rng, Packet16i, Rand::RandomEngineType::packet>
+		{
+			EIGEN_STRONG_INLINE Packet8i rawbits(Rng& rng)
+			{
+				return rng.half();
+			}
+
+			EIGEN_STRONG_INLINE Packet8i rawbits_34(Rng& rng)
+			{
+				return rng.half();
+			}
+
+			EIGEN_STRONG_INLINE Packet8i rawbits_half(Rng& rng)
+			{
+				return rng.half();
+			}
+		};
+
+		template<typename Rng>
+		struct RawbitsMaker<Packet16i, Rng, Packet8i, Rand::RandomEngineType::packet>
+		{
+			EIGEN_STRONG_INLINE Packet16i rawbits(Rng& rng)
+			{
+				return _mm512_inserti64x4(_mm512_castsi256_si512(rng()), rng(), 1);
+			}
+
+			EIGEN_STRONG_INLINE Packet16i rawbits_34(Rng& rng)
+			{
+				return _mm512_inserti64x4(_mm512_castsi256_si512(rng()), rng(), 1);
+			}
+
+			EIGEN_STRONG_INLINE Packet8i rawbits_half(Rng& rng)
+			{
+				return rng();
+			}
+		};
+
+		template<typename Rng, typename RngResult>
+		struct RawbitsMaker<Packet16i, Rng, RngResult, Rand::RandomEngineType::scalar_fullbit>
+		{
+			EIGEN_STRONG_INLINE Packet16i rawbits(Rng& rng)
+			{
+				if (sizeof(decltype(rng())) == 8)
+				{
+					return _mm512_set_epi64(rng(), rng(), rng(), rng(),
+						rng(), rng(), rng(), rng());
+				}
+				else
+				{
+					return _mm512_set_epi32(rng(), rng(), rng(), rng(),
+						rng(), rng(), rng(), rng(),
+						rng(), rng(), rng(), rng(),
+						rng(), rng(), rng(), rng());
+				}
+			}
+
+			EIGEN_STRONG_INLINE Packet16i rawbits_34(Rng& rng)
+			{
+				return rawbits(rng);
+			}
+
+			EIGEN_STRONG_INLINE Packet8i rawbits_half(Rng& rng)
+			{
+				if (sizeof(decltype(rng())) == 8)
+				{
+					return _mm256_set_epi64x(rng(), rng(), rng(), rng());
+				}
+				else
+				{
+					return _mm256_set_epi32(rng(), rng(), rng(), rng(),
+						rng(), rng(), rng(), rng());
+				}
+			}
+		};
+
+		template<typename Rng>
+		struct RawbitsMaker<Packet16i, Rng, Packet16i, Rand::RandomEngineType::packet>
+		{
+			EIGEN_STRONG_INLINE Packet16i rawbits(Rng& rng)
+			{
+				return rng();
+			}
+
+			EIGEN_STRONG_INLINE Packet16i rawbits_34(Rng& rng)
+			{
+				return rng();
+			}
+
+			EIGEN_STRONG_INLINE Packet8i rawbits_half(Rng& rng)
+			{
+				return rng.half();
+			}
+		};
+
+		template<typename Rng>
+		struct UniformRealUtils<Packet16f, Rng> : public RawbitsMaker<Packet16i, Rng>
+		{
+			EIGEN_STRONG_INLINE Packet16f zero_to_one(Rng& rng)
+			{
+				return pdiv(_mm512_cvtepi32_ps(pand(this->rawbits(rng), pset1<Packet16i>(0x7FFFFFFF))),
+					pset1<Packet16f>(0x7FFFFFFF));
+			}
+
+			EIGEN_STRONG_INLINE Packet16f uniform_real(Rng& rng)
+			{
+				return bit_to_ur_float(this->rawbits_34(rng));
+			}
+		};
+
+		template<typename Rng>
+		struct UniformRealUtils<Packet8d, Rng> : public RawbitsMaker<Packet16i, Rng>
+		{
+			EIGEN_STRONG_INLINE Packet8d zero_to_one(Rng& rng)
+			{
+				return pdiv(_mm512_cvtepi32_pd(pand(this->rawbits_half(rng), pset1<Packet8i>(0x7FFFFFFF))),
+					pset1<Packet8d>(0x7FFFFFFF));
+			}
+
+			EIGEN_STRONG_INLINE Packet8d uniform_real(Rng& rng)
+			{
+				return bit_to_ur_double(this->rawbits(rng));
+			}
+		};
+	}
+}
+#endif

data/vendor/EigenRand/EigenRand/arch/NEON/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
  *
  */
 
@@ -46,6 +46,9 @@ namespace Eigen
 		template<>
 		struct IsFloatPacket<Packet4f> : std::true_type {};
 
+		template<>
+		struct IsDoublePacket<Packet2d> : std::true_type {};
+
 		template<>
 		struct HalfPacket<Packet4i>
 		{
@@ -64,6 +67,11 @@ namespace Eigen
 			{
 				return x;
 			}
+
+			EIGEN_STRONG_INLINE Packet2d to_double(const Packet4i& x)
+			{
+				return (Packet2d)vreinterpretq_f64_s32(x);
+			}
 		};
 
 		template<>
@@ -78,6 +86,30 @@ namespace Eigen
 			{
 				return (Packet4i)vreinterpretq_s32_f32(x);
 			}
+
+			EIGEN_STRONG_INLINE Packet2d to_double(const Packet4f& x)
+			{
+				return (Packet2d)vreinterpretq_f64_f32(x);
+			}
+		};
+
+		template<>
+		struct reinterpreter<Packet2d>
+		{
+			EIGEN_STRONG_INLINE Packet4f to_float(const Packet2d& x)
+			{
+				return vreinterpretq_f32_f64(x);
+			}
+
+			EIGEN_STRONG_INLINE Packet2d to_double(const Packet2d& x)
+			{
+				return x;
+			}
+
+			EIGEN_STRONG_INLINE Packet4i to_int(const Packet2d& x)
+			{
+				return vreinterpretq_s32_f64(x);
+			}
 		};
 
 		template<>
@@ -192,6 +224,18 @@ namespace Eigen
 			return vreinterpretq_f32_u32(vcleq_f32(a, b));
 		}
 
+		template<>
+		EIGEN_STRONG_INLINE Packet2d pcmplt<Packet2d>(const Packet2d& a, const Packet2d& b)
+		{
+			return vreinterpretq_f64_u64(vcltq_f64(a,b));
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet2d pcmple<Packet2d>(const Packet2d& a, const Packet2d& b)
+		{
+			return vreinterpretq_f64_u64(vcleq_f64(a,b));
+		}
+
 		template<>
 		EIGEN_STRONG_INLINE Packet4f pblendv(const Packet4f& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket)
 		{
@@ -210,6 +254,18 @@ namespace Eigen
 			return vbslq_s32(vreinterpretq_u32_s32(ifPacket), thenPacket, elsePacket);
 		}
 
+		template<>
+		EIGEN_STRONG_INLINE Packet2d pblendv(const Packet2d& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket)
+		{
+			return vbslq_f64(vreinterpretq_u64_f64(ifPacket), thenPacket, elsePacket);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet2d pblendv(const Packet4i& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket)
+		{
+			return vbslq_f64(vreinterpretq_u64_s32(ifPacket), thenPacket, elsePacket);
+		}
+
 		template<>
 		EIGEN_STRONG_INLINE Packet4i pgather<Packet4i>(const int* addr, const Packet4i& index)
 		{
@@ -256,6 +312,37 @@ namespace Eigen
 		{
 			return vrndq_f32(a);
 		}
+		
+		template<>
+		EIGEN_STRONG_INLINE Packet4i pcast64<Packet2d, Packet4i>(const Packet2d& a)
+		{
+			return (Packet4i)vcvtq_s64_f64(a);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet2d pcast64<Packet4i, Packet2d>(const Packet4i& a)
+		{
+			return vcvtq_f64_s64((int64x2_t)a);
+		}
+
+
+		template<>
+		EIGEN_STRONG_INLINE Packet4i padd64<Packet4i>(const Packet4i& a, const Packet4i& b)
+		{
+			return (Packet4i)vaddq_s64((int64x2_t)a, (int64x2_t)b);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet4i psub64<Packet4i>(const Packet4i& a, const Packet4i& b)
+		{
+			return (Packet4i)vsubq_s64((int64x2_t)a, (int64x2_t)b);
+		}
+
+		template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+			Packet2d psin<Packet2d>(const Packet2d& x)
+		{
+			return _psin(x);
+		}
 
 		template<>
 		EIGEN_STRONG_INLINE Packet4i pseti64<Packet4i>(uint64_t a)
@@ -279,7 +366,35 @@ namespace Eigen
 			return vreinterpretq_s32_u64(vld1q_u64(u));
 		}
 
+		template<> 
+		EIGEN_STRONG_INLINE bool predux_all(const Packet4f& x)
+		{
+			uint32x2_t tmp = vand_u32(vget_low_u32( vreinterpretq_u32_f32(x)),
+										vget_high_u32(vreinterpretq_u32_f32(x)));
+			return vget_lane_u32(vpmin_u32(tmp, tmp), 0);
+		}
+
+		template<> 
+		EIGEN_STRONG_INLINE bool predux_all(const Packet4i& x)
+		{
+			return predux_all((Packet4f)vreinterpretq_f32_s32(x));
+		}
+
 	#ifdef EIGENRAND_EIGEN_33_MODE
+		template<> 
+		EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x)
+		{
+			uint32x2_t tmp = vorr_u32(vget_low_u32( vreinterpretq_u32_f32(x)),
+										vget_high_u32(vreinterpretq_u32_f32(x)));
+			return vget_lane_u32(vpmax_u32(tmp, tmp), 0);
+		}
+
+		template<> 
+		EIGEN_STRONG_INLINE bool predux_any(const Packet4i& x)
+		{
+			return predux_any((Packet4f)vreinterpretq_f32_s32(x));
+		}
+
 		template<>
 		EIGEN_STRONG_INLINE Packet4f plog<Packet4f>(const Packet4f& _x)
 		{