Go to the documentation of this file.
12 #ifndef EIGEN_PACKET_MATH_NEON_H
13 #define EIGEN_PACKET_MATH_NEON_H
19 #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
20 #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
23 #ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
24 #define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
27 #ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
29 #define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
31 #define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 16
35 #if EIGEN_COMP_MSVC_STRICT
41 typedef eigen_packet_wrapper<float32x2_t,0>
Packet2f;
42 typedef eigen_packet_wrapper<float32x4_t,1>
Packet4f;
43 typedef eigen_packet_wrapper<int32_t ,2>
Packet4c;
44 typedef eigen_packet_wrapper<int8x8_t ,3>
Packet8c;
45 typedef eigen_packet_wrapper<int8x16_t ,4>
Packet16c;
46 typedef eigen_packet_wrapper<uint32_t ,5>
Packet4uc;
47 typedef eigen_packet_wrapper<uint8x8_t ,6>
Packet8uc;
48 typedef eigen_packet_wrapper<uint8x16_t ,7>
Packet16uc;
49 typedef eigen_packet_wrapper<int16x4_t ,8>
Packet4s;
50 typedef eigen_packet_wrapper<int16x8_t ,9>
Packet8s;
51 typedef eigen_packet_wrapper<uint16x4_t ,10>
Packet4us;
52 typedef eigen_packet_wrapper<uint16x8_t ,11>
Packet8us;
53 typedef eigen_packet_wrapper<int32x2_t ,12>
Packet2i;
54 typedef eigen_packet_wrapper<int32x4_t ,13>
Packet4i;
55 typedef eigen_packet_wrapper<uint32x2_t ,14>
Packet2ui;
56 typedef eigen_packet_wrapper<uint32x4_t ,15>
Packet4ui;
57 typedef eigen_packet_wrapper<int64x2_t ,16>
Packet2l;
58 typedef eigen_packet_wrapper<uint64x2_t ,17>
Packet2ul;
81 #endif // EIGEN_COMP_MSVC_STRICT
84 const float*
a =
reinterpret_cast<const float*
>(&
m);
85 Packet4f res = {*(
a + (mask & 3)), *(
a + ((mask >> 2) & 3)), *(
a + ((mask >> 4) & 3 )), *(
a + ((mask >> 6) & 3))};
93 template<
bool interleave>
96 const float*
a =
reinterpret_cast<const float*
>(&
m);
97 const float*
b =
reinterpret_cast<const float*
>(&
n);
98 Packet4f res = {*(
a + (mask & 3)), *(
a + ((mask >> 2) & 3)), *(
b + ((mask >> 4) & 3)), *(
b + ((mask >> 6) & 3))};
105 const float*
a =
reinterpret_cast<const float*
>(&
m);
106 const float*
b =
reinterpret_cast<const float*
>(&
n);
107 Packet4f res = {*(
a + (mask & 3)), *(
b + ((mask >> 2) & 3)), *(
a + ((mask >> 4) & 3)), *(
b + ((mask >> 6) & 3))};
137 #define vec4f_duplane(a, p) \
138 vdupq_lane_f32(vget_low_f32(a), p)
140 #define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
141 const Packet4f p4f_##NAME = pset1<Packet4f>(X)
143 #define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
144 const Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1<int32_t>(X))
146 #define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
147 const Packet4i p4i_##NAME = pset1<Packet4i>(X)
153 #define EIGEN_ARM_PREFETCH(ADDR) __asm__ __volatile__("prfm pldl1keep, [%[addr]]\n" ::[addr] "r"(ADDR) : );
154 #elif EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
155 #define EIGEN_ARM_PREFETCH(ADDR) __builtin_prefetch(ADDR);
157 #define EIGEN_ARM_PREFETCH(ADDR) __pld(ADDR)
158 #elif EIGEN_ARCH_ARM32
159 #define EIGEN_ARM_PREFETCH(ADDR) __asm__ __volatile__ ("pld [%[addr]]\n" :: [addr] "r" (ADDR) : );
162 #define EIGEN_ARM_PREFETCH(ADDR)
166 struct packet_traits<
float> : default_packet_traits
330 struct packet_traits<
int32_t> : default_packet_traits
449 #if EIGEN_GNUC_AT_MOST(4, 4) && !EIGEN_COMP_LLVM
451 EIGEN_STRONG_INLINE float32x4_t vld1q_f32(
const float*
x) { return ::vld1q_f32((
const float32_t*)
x); }
452 EIGEN_STRONG_INLINE float32x2_t vld1_f32(
const float*
x) { return ::vld1_f32 ((
const float32_t*)
x); }
453 EIGEN_STRONG_INLINE float32x2_t vld1_dup_f32(
const float*
x) { return ::vld1_dup_f32 ((
const float32_t*)
x); }
454 EIGEN_STRONG_INLINE void vst1q_f32(
float* to, float32x4_t from) { ::vst1q_f32((float32_t*)to,from); }
455 EIGEN_STRONG_INLINE void vst1_f32 (
float* to, float32x2_t from) { ::vst1_f32 ((float32_t*)to,from); }
472 template<>
struct unpacket_traits<
Packet4f>
512 template<>
struct unpacket_traits<
Packet16c>
576 template<>
struct unpacket_traits<
Packet8s>
602 template<>
struct unpacket_traits<
Packet8us>
628 template<>
struct unpacket_traits<
Packet4i>
697 {
return vget_lane_s32(vreinterpret_s32_s8(vdup_n_s8(from)), 0); }
701 {
return vget_lane_u32(vreinterpret_u32_u8(vdup_n_u8(from)), 0); }
716 {
return vreinterpret_f32_u32(vdup_n_u32(from)); }
718 {
return vreinterpretq_f32_u32(vdupq_n_u32(from)); }
722 const float c[] = {0.0f,1.0f};
727 const float c[] = {0.0f,1.0f,2.0f,3.0f};
731 {
return vget_lane_s32(vreinterpret_s32_s8(vadd_s8(vreinterpret_s8_u32(vdup_n_u32(0x03020100)), vdup_n_s8(
a))), 0); }
734 const int8_t c[] = {0,1,2,3,4,5,6,7};
739 const int8_t c[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
743 {
return vget_lane_u32(vreinterpret_u32_u8(vadd_u8(vreinterpret_u8_u32(vdup_n_u32(0x03020100)), vdup_n_u8(
a))), 0); }
746 const uint8_t c[] = {0,1,2,3,4,5,6,7};
751 const uint8_t c[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
766 const int16_t c[] = {0,1,2,3,4,5,6,7};
809 return vget_lane_s32(vreinterpret_s32_s8(vadd_s8(
810 vreinterpret_s8_s32(vdup_n_s32(
a)),
811 vreinterpret_s8_s32(vdup_n_s32(
b)))), 0);
817 return vget_lane_u32(vreinterpret_u32_u8(vadd_u8(
818 vreinterpret_u8_u32(vdup_n_u32(
a)),
819 vreinterpret_u8_u32(vdup_n_u32(
b)))), 0);
838 return vget_lane_s32(vreinterpret_s32_s8(vsub_s8(
839 vreinterpret_s8_s32(vdup_n_s32(
a)),
840 vreinterpret_s8_s32(vdup_n_s32(
b)))), 0);
846 return vget_lane_u32(vreinterpret_u32_u8(vsub_u8(
847 vreinterpret_u8_u32(vdup_n_u32(
a)),
848 vreinterpret_u8_u32(vdup_n_u32(
b)))), 0);
865 Packet2f mask = {numext::bit_cast<float>(0x80000000u), 0.0f};
870 Packet4f mask = {numext::bit_cast<float>(0x80000000u), 0.0f, numext::bit_cast<float>(0x80000000u), 0.0f};
877 {
return vget_lane_s32(vreinterpret_s32_s8(vneg_s8(vreinterpret_s8_s32(vdup_n_s32(
a)))), 0); }
889 vdup_n_s64(-vgetq_lane_s64(
a, 0)),
890 vdup_n_s64(-vgetq_lane_s64(
a, 1)));
917 return vget_lane_s32(vreinterpret_s32_s8(vmul_s8(
918 vreinterpret_s8_s32(vdup_n_s32(
a)),
919 vreinterpret_s8_s32(vdup_n_s32(
b)))), 0);
925 return vget_lane_u32(vreinterpret_u32_u8(vmul_u8(
926 vreinterpret_u8_u32(vdup_n_u32(
a)),
927 vreinterpret_u8_u32(vdup_n_u32(
b)))), 0);
941 vdup_n_s64(vgetq_lane_s64(
a, 0)*vgetq_lane_s64(
b, 0)),
942 vdup_n_s64(vgetq_lane_s64(
a, 1)*vgetq_lane_s64(
b, 1)));
946 vdup_n_u64(vgetq_lane_u64(
a, 0)*vgetq_lane_u64(
b, 0)),
947 vdup_n_u64(vgetq_lane_u64(
a, 1)*vgetq_lane_u64(
b, 1)));
953 return vdiv_f32(
a,
b);
966 restep = vrecps_f32(
b, inv);
967 inv = vmul_f32(restep, inv);
970 div = vmul_f32(
a, inv);
978 return vdivq_f32(
a,
b);
987 inv = vrecpeq_f32(
b);
991 restep = vrecpsq_f32(
b, inv);
992 inv = vmulq_f32(restep, inv);
995 div = vmulq_f32(
a, inv);
1003 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1008 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1013 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1018 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1023 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1028 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1033 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1038 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1043 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1048 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1053 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1058 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1063 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1068 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1073 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1078 eigen_assert(
false &&
"packet integer division are not supported by NEON");
1083 #ifdef __ARM_FEATURE_FMA
1085 {
return vfmaq_f32(
c,
a,
b); }
1087 {
return vfma_f32(
c,
a,
b); }
1091 return vmlaq_f32(
c,
a,
b);
1095 return vmla_f32(
c,
a,
b);
1102 return vget_lane_s32(vreinterpret_s32_s8(vmla_s8(
1103 vreinterpret_s8_s32(vdup_n_s32(
c)),
1104 vreinterpret_s8_s32(vdup_n_s32(
a)),
1105 vreinterpret_s8_s32(vdup_n_s32(
b)))), 0);
1108 {
return vmla_s8(
c,
a,
b); }
1110 {
return vmlaq_s8(
c,
a,
b); }
1113 return vget_lane_u32(vreinterpret_u32_u8(vmla_u8(
1114 vreinterpret_u8_u32(vdup_n_u32(
c)),
1115 vreinterpret_u8_u32(vdup_n_u32(
a)),
1116 vreinterpret_u8_u32(vdup_n_u32(
b)))), 0);
1119 {
return vmla_u8(
c,
a,
b); }
1121 {
return vmlaq_u8(
c,
a,
b); }
1123 {
return vmla_s16(
c,
a,
b); }
1125 {
return vmlaq_s16(
c,
a,
b); }
1127 {
return vmla_u16(
c,
a,
b); }
1129 {
return vmlaq_u16(
c,
a,
b); }
1131 {
return vmla_s32(
c,
a,
b); }
1133 {
return vmlaq_s32(
c,
a,
b); }
1135 {
return vmla_u32(
c,
a,
b); }
1137 {
return vmlaq_u32(
c,
a,
b); }
1140 {
return vabd_f32(
a,
b); }
1142 {
return vabdq_f32(
a,
b); }
1145 return vget_lane_s32(vreinterpret_s32_s8(vabd_s8(
1146 vreinterpret_s8_s32(vdup_n_s32(
a)),
1147 vreinterpret_s8_s32(vdup_n_s32(
b)))), 0);
1150 {
return vabd_s8(
a,
b); }
1152 {
return vabdq_s8(
a,
b); }
1155 return vget_lane_u32(vreinterpret_u32_u8(vabd_u8(
1156 vreinterpret_u8_u32(vdup_n_u32(
a)),
1157 vreinterpret_u8_u32(vdup_n_u32(
b)))), 0);
1160 {
return vabd_u8(
a,
b); }
1162 {
return vabdq_u8(
a,
b); }
1164 {
return vabd_s16(
a,
b); }
1166 {
return vabdq_s16(
a,
b); }
1168 {
return vabd_u16(
a,
b); }
1170 {
return vabdq_u16(
a,
b); }
1172 {
return vabd_s32(
a,
b); }
1174 {
return vabdq_s32(
a,
b); }
1176 {
return vabd_u32(
a,
b); }
1178 {
return vabdq_u32(
a,
b); }
1183 #ifdef __ARM_FEATURE_NUMERIC_MAXMIN
1195 return vget_lane_s32(vreinterpret_s32_s8(vmin_s8(
1196 vreinterpret_s8_s32(vdup_n_s32(
a)),
1197 vreinterpret_s8_s32(vdup_n_s32(
b)))), 0);
1203 return vget_lane_u32(vreinterpret_u32_u8(vmin_u8(
1204 vreinterpret_u8_u32(vdup_n_u32(
a)),
1205 vreinterpret_u8_u32(vdup_n_u32(
b)))), 0);
1218 return vcombine_s64(
1219 vdup_n_s64((
std::min)(vgetq_lane_s64(
a, 0), vgetq_lane_s64(
b, 0))),
1220 vdup_n_s64((
std::min)(vgetq_lane_s64(
a, 1), vgetq_lane_s64(
b, 1))));
1223 return vcombine_u64(
1224 vdup_n_u64((
std::min)(vgetq_lane_u64(
a, 0), vgetq_lane_u64(
b, 0))),
1225 vdup_n_u64((
std::min)(vgetq_lane_u64(
a, 1), vgetq_lane_u64(
b, 1))));
1231 #ifdef __ARM_FEATURE_NUMERIC_MAXMIN
1243 return vget_lane_s32(vreinterpret_s32_s8(vmax_s8(
1244 vreinterpret_s8_s32(vdup_n_s32(
a)),
1245 vreinterpret_s8_s32(vdup_n_s32(
b)))), 0);
1251 return vget_lane_u32(vreinterpret_u32_u8(vmax_u8(
1252 vreinterpret_u8_u32(vdup_n_u32(
a)),
1253 vreinterpret_u8_u32(vdup_n_u32(
b)))), 0);
1266 return vcombine_s64(
1267 vdup_n_s64((
std::max)(vgetq_lane_s64(
a, 0), vgetq_lane_s64(
b, 0))),
1268 vdup_n_s64((
std::max)(vgetq_lane_s64(
a, 1), vgetq_lane_s64(
b, 1))));
1271 return vcombine_u64(
1272 vdup_n_u64((
std::max)(vgetq_lane_u64(
a, 0), vgetq_lane_u64(
b, 0))),
1273 vdup_n_u64((
std::max)(vgetq_lane_u64(
a, 1), vgetq_lane_u64(
b, 1))));
1277 {
return vreinterpret_f32_u32(vcle_f32(
a,
b)); }
1279 {
return vreinterpretq_f32_u32(vcleq_f32(
a,
b)); }
1282 return vget_lane_s32(vreinterpret_s32_u8(vcle_s8(
1283 vreinterpret_s8_s32(vdup_n_s32(
a)),
1284 vreinterpret_s8_s32(vdup_n_s32(
b)))), 0);
1287 {
return vreinterpret_s8_u8(vcle_s8(
a,
b)); }
1289 {
return vreinterpretq_s8_u8(vcleq_s8(
a,
b)); }
1292 return vget_lane_u32(vreinterpret_u32_u8(vcle_u8(
1293 vreinterpret_u8_u32(vdup_n_u32(
a)),
1294 vreinterpret_u8_u32(vdup_n_u32(
b)))), 0);
1297 {
return vcle_u8(
a,
b); }
1299 {
return vcleq_u8(
a,
b); }
1301 {
return vreinterpret_s16_u16(vcle_s16(
a,
b)); }
1303 {
return vreinterpretq_s16_u16(vcleq_s16(
a,
b)); }
1305 {
return vcle_u16(
a,
b); }
1307 {
return vcleq_u16(
a,
b); }
1309 {
return vreinterpret_s32_u32(vcle_s32(
a,
b)); }
1311 {
return vreinterpretq_s32_u32(vcleq_s32(
a,
b)); }
1313 {
return vcle_u32(
a,
b); }
1315 {
return vcleq_u32(
a,
b); }
1318 #if EIGEN_ARCH_ARM64
1319 return vreinterpretq_s64_u64(vcleq_s64(
a,
b));
1321 return vcombine_s64(
1322 vdup_n_s64(vgetq_lane_s64(
a, 0) <= vgetq_lane_s64(
b, 0) ?
numext::int64_t(-1) : 0),
1323 vdup_n_s64(vgetq_lane_s64(
a, 1) <= vgetq_lane_s64(
b, 1) ?
numext::int64_t(-1) : 0));
1328 #if EIGEN_ARCH_ARM64
1329 return vcleq_u64(
a,
b);
1331 return vcombine_u64(
1333 vdup_n_u64(vgetq_lane_u64(
a, 1) <= vgetq_lane_u64(
b, 1) ?
numext::uint64_t(-1) : 0));
1338 {
return vreinterpret_f32_u32(vclt_f32(
a,
b)); }
1340 {
return vreinterpretq_f32_u32(vcltq_f32(
a,
b)); }
1343 return vget_lane_s32(vreinterpret_s32_u8(vclt_s8(
1344 vreinterpret_s8_s32(vdup_n_s32(
a)),
1345 vreinterpret_s8_s32(vdup_n_s32(
b)))), 0);
1348 {
return vreinterpret_s8_u8(vclt_s8(
a,
b)); }
1350 {
return vreinterpretq_s8_u8(vcltq_s8(
a,
b)); }
1353 return vget_lane_u32(vreinterpret_u32_u8(vclt_u8(
1354 vreinterpret_u8_u32(vdup_n_u32(
a)),
1355 vreinterpret_u8_u32(vdup_n_u32(
b)))), 0);
1358 {
return vclt_u8(
a,
b); }
1360 {
return vcltq_u8(
a,
b); }
1362 {
return vreinterpret_s16_u16(vclt_s16(
a,
b)); }
1364 {
return vreinterpretq_s16_u16(vcltq_s16(
a,
b)); }
1366 {
return vclt_u16(
a,
b); }
1368 {
return vcltq_u16(
a,
b); }
1370 {
return vreinterpret_s32_u32(vclt_s32(
a,
b)); }
1372 {
return vreinterpretq_s32_u32(vcltq_s32(
a,
b)); }
1374 {
return vclt_u32(
a,
b); }
1376 {
return vcltq_u32(
a,
b); }
1379 #if EIGEN_ARCH_ARM64
1380 return vreinterpretq_s64_u64(vcltq_s64(
a,
b));
1382 return vcombine_s64(
1383 vdup_n_s64(vgetq_lane_s64(
a, 0) < vgetq_lane_s64(
b, 0) ?
numext::int64_t(-1) : 0),
1384 vdup_n_s64(vgetq_lane_s64(
a, 1) < vgetq_lane_s64(
b, 1) ?
numext::int64_t(-1) : 0));
1389 #if EIGEN_ARCH_ARM64
1390 return vcltq_u64(
a,
b);
1392 return vcombine_u64(
1399 {
return vreinterpret_f32_u32(vceq_f32(
a,
b)); }
1401 {
return vreinterpretq_f32_u32(vceqq_f32(
a,
b)); }
1404 return vget_lane_s32(vreinterpret_s32_u8(vceq_s8(
1405 vreinterpret_s8_s32(vdup_n_s32(
a)),
1406 vreinterpret_s8_s32(vdup_n_s32(
b)))), 0);
1409 {
return vreinterpret_s8_u8(vceq_s8(
a,
b)); }
1411 {
return vreinterpretq_s8_u8(vceqq_s8(
a,
b)); }
1414 return vget_lane_u32(vreinterpret_u32_u8(vceq_u8(
1415 vreinterpret_u8_u32(vdup_n_u32(
a)),
1416 vreinterpret_u8_u32(vdup_n_u32(
b)))), 0);
1419 {
return vceq_u8(
a,
b); }
1421 {
return vceqq_u8(
a,
b); }
1423 {
return vreinterpret_s16_u16(vceq_s16(
a,
b)); }
1425 {
return vreinterpretq_s16_u16(vceqq_s16(
a,
b)); }
1427 {
return vceq_u16(
a,
b); }
1429 {
return vceqq_u16(
a,
b); }
1431 {
return vreinterpret_s32_u32(vceq_s32(
a,
b)); }
1433 {
return vreinterpretq_s32_u32(vceqq_s32(
a,
b)); }
1435 {
return vceq_u32(
a,
b); }
1437 {
return vceqq_u32(
a,
b); }
1440 #if EIGEN_ARCH_ARM64
1441 return vreinterpretq_s64_u64(vceqq_s64(
a,
b));
1443 return vcombine_s64(
1444 vdup_n_s64(vgetq_lane_s64(
a, 0) == vgetq_lane_s64(
b, 0) ?
numext::int64_t(-1) : 0),
1445 vdup_n_s64(vgetq_lane_s64(
a, 1) == vgetq_lane_s64(
b, 1) ?
numext::int64_t(-1) : 0));
1450 #if EIGEN_ARCH_ARM64
1451 return vceqq_u64(
a,
b);
1453 return vcombine_u64(
1455 vdup_n_u64(vgetq_lane_u64(
a, 1) == vgetq_lane_u64(
b, 1) ?
numext::uint64_t(-1) : 0));
1460 {
return vreinterpret_f32_u32(vmvn_u32(vcge_f32(
a,
b))); }
1462 {
return vreinterpretq_f32_u32(vmvnq_u32(vcgeq_f32(
a,
b))); }
1466 {
return vreinterpret_f32_u32(vand_u32(vreinterpret_u32_f32(
a),vreinterpret_u32_f32(
b))); }
1468 {
return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(
a),vreinterpretq_u32_f32(
b))); }
1472 {
return vand_s8(
a,
b); }
1474 {
return vandq_s8(
a,
b); }
1478 {
return vand_u8(
a,
b); }
1480 {
return vandq_u8(
a,
b); }
1484 {
return vand_u16(
a,
b); }
1486 {
return vandq_u16(
a,
b); }
1490 {
return vand_u32(
a,
b); }
1492 {
return vandq_u32(
a,
b); }
1495 {
return vandq_u64(
a,
b); }
1498 {
return vreinterpret_f32_u32(vorr_u32(vreinterpret_u32_f32(
a),vreinterpret_u32_f32(
b))); }
1500 {
return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(
a),vreinterpretq_u32_f32(
b))); }
1505 {
return vorrq_s8(
a,
b); }
1509 {
return vorr_u8(
a,
b); }
1511 {
return vorrq_u8(
a,
b); }
1513 {
return vorr_s16(
a,
b); }
1515 {
return vorrq_s16(
a,
b); }
1517 {
return vorr_u16(
a,
b); }
1519 {
return vorrq_u16(
a,
b); }
1523 {
return vorr_u32(
a,
b); }
1525 {
return vorrq_u32(
a,
b); }
1527 {
return vorrq_s64(
a,
b); }
1529 {
return vorrq_u64(
a,
b); }
1532 {
return vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(
a),vreinterpret_u32_f32(
b))); }
1534 {
return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(
a),vreinterpretq_u32_f32(
b))); }
1538 {
return veor_s8(
a,
b); }
1540 {
return veorq_s8(
a,
b); }
1544 {
return veor_u8(
a,
b); }
1546 {
return veorq_u8(
a,
b); }
1550 {
return veor_u16(
a,
b); }
1552 {
return veorq_u16(
a,
b); }
1556 {
return veor_u32(
a,
b); }
1558 {
return veorq_u32(
a,
b); }
1560 {
return veorq_s64(
a,
b); }
1562 {
return veorq_u64(
a,
b); }
1565 {
return vreinterpret_f32_u32(vbic_u32(vreinterpret_u32_f32(
a),vreinterpret_u32_f32(
b))); }
1567 {
return vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(
a),vreinterpretq_u32_f32(
b))); }
1575 {
return vbic_u8(
a,
b); }
1577 {
return vbicq_u8(
a,
b); }
1579 {
return vbic_s16(
a,
b); }
1581 {
return vbicq_s16(
a,
b); }
1583 {
return vbic_u16(
a,
b); }
1585 {
return vbicq_u16(
a,
b); }
1587 {
return vbic_s32(
a,
b); }
1589 {
return vbicq_s32(
a,
b); }
1591 {
return vbic_u32(
a,
b); }
1593 {
return vbicq_u32(
a,
b); }
1595 {
return vbicq_s64(
a,
b); }
1597 {
return vbicq_u64(
a,
b); }
1601 {
return vget_lane_s32(vreinterpret_s32_s8(vshr_n_s8(vreinterpret_s8_s32(vdup_n_s32(
a)),
N)), 0); }
1605 {
return vget_lane_u32(vreinterpret_u32_u8(vshr_n_u8(vreinterpret_u8_u32(vdup_n_u32(
a)),
N)), 0); }
1620 {
return vget_lane_s32(vreinterpret_s32_u8(vshr_n_u8(vreinterpret_u8_s32(vdup_n_s32(
a)),
N)), 0); }
1622 {
return vreinterpret_s8_u8(vshr_n_u8(vreinterpret_u8_s8(
a),
N)); }
1624 {
return vreinterpretq_s8_u8(vshrq_n_u8(vreinterpretq_u8_s8(
a),
N)); }
1626 {
return vget_lane_u32(vreinterpret_u32_s8(vshr_n_s8(vreinterpret_s8_u32(vdup_n_u32(
a)),
N)), 0); }
1630 {
return vreinterpret_s16_u16(vshr_n_u16(vreinterpret_u16_s16(
a),
N)); }
1632 {
return vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(
a),
N)); }
1636 {
return vreinterpret_s32_u32(vshr_n_u32(vreinterpret_u32_s32(
a),
N)); }
1638 {
return vreinterpretq_s32_u32(vshrq_n_u32(vreinterpretq_u32_s32(
a),
N)); }
1642 {
return vreinterpretq_s64_u64(vshrq_n_u64(vreinterpretq_u64_s64(
a),
N)); }
1646 {
return vget_lane_s32(vreinterpret_s32_s8(vshl_n_s8(vreinterpret_s8_s32(vdup_n_s32(
a)),
N)), 0); }
1650 {
return vget_lane_u32(vreinterpret_u32_u8(vshl_n_u8(vreinterpret_u8_u32(vdup_n_u32(
a)),
N)), 0); }
1755 {
return vld1_dup_f32(from); }
1757 {
return vcombine_f32(vld1_dup_f32(from), vld1_dup_f32(from+1)); }
1761 return vget_lane_s32(vreinterpret_s32_s8(vzip_s8(
a,
a).val[0]), 0);
1765 const int8x8_t
a = vld1_s8(from);
1766 return vzip_s8(
a,
a).val[0];
1770 const int8x8_t
a = vld1_s8(from);
1771 const int8x8x2_t
b = vzip_s8(
a,
a);
1772 return vcombine_s8(
b.val[0],
b.val[1]);
1777 return vget_lane_u32(vreinterpret_u32_u8(vzip_u8(
a,
a).val[0]), 0);
1781 const uint8x8_t
a = vld1_u8(from);
1782 return vzip_u8(
a,
a).val[0];
1786 const uint8x8_t
a = vld1_u8(from);
1787 const uint8x8x2_t
b = vzip_u8(
a,
a);
1788 return vcombine_u8(
b.val[0],
b.val[1]);
1792 return vreinterpret_s16_u32(vzip_u32(vreinterpret_u32_s16(vld1_dup_s16(from)),
1793 vreinterpret_u32_s16(vld1_dup_s16(from+1))).val[0]);
1797 const int16x4_t
a = vld1_s16(from);
1798 const int16x4x2_t
b = vzip_s16(
a,
a);
1799 return vcombine_s16(
b.val[0],
b.val[1]);
1803 return vreinterpret_u16_u32(vzip_u32(vreinterpret_u32_u16(vld1_dup_u16(from)),
1804 vreinterpret_u32_u16(vld1_dup_u16(from+1))).val[0]);
1808 const uint16x4_t
a = vld1_u16(from);
1809 const uint16x4x2_t
b = vzip_u16(
a,
a);
1810 return vcombine_u16(
b.val[0],
b.val[1]);
1813 {
return vld1_dup_s32(from); }
1815 {
return vcombine_s32(vld1_dup_s32(from), vld1_dup_s32(from+1)); }
1817 {
return vld1_dup_u32(from); }
1819 {
return vcombine_u32(vld1_dup_u32(from), vld1_dup_u32(from+1)); }
1821 {
return vld1q_dup_s64(from); }
1823 {
return vld1q_dup_u64(from); }
1827 {
return vget_lane_s32(vreinterpret_s32_s8(vld1_dup_s8(from)), 0); }
1830 return vreinterpret_s8_u32(vzip_u32(
1831 vreinterpret_u32_s8(vld1_dup_s8(from)),
1832 vreinterpret_u32_s8(vld1_dup_s8(from+1))).val[0]);
1836 const int8x8_t
a = vreinterpret_s8_u32(vzip_u32(
1837 vreinterpret_u32_s8(vld1_dup_s8(from)),
1838 vreinterpret_u32_s8(vld1_dup_s8(from+1))).val[0]);
1839 const int8x8_t
b = vreinterpret_s8_u32(vzip_u32(
1840 vreinterpret_u32_s8(vld1_dup_s8(from+2)),
1841 vreinterpret_u32_s8(vld1_dup_s8(from+3))).val[0]);
1842 return vcombine_s8(
a,
b);
1845 {
return vget_lane_u32(vreinterpret_u32_u8(vld1_dup_u8(from)), 0); }
1848 return vreinterpret_u8_u32(vzip_u32(
1849 vreinterpret_u32_u8(vld1_dup_u8(from)),
1850 vreinterpret_u32_u8(vld1_dup_u8(from+1))).val[0]);
1854 const uint8x8_t
a = vreinterpret_u8_u32(vzip_u32(
1855 vreinterpret_u32_u8(vld1_dup_u8(from)),
1856 vreinterpret_u32_u8(vld1_dup_u8(from+1))).val[0]);
1857 const uint8x8_t
b = vreinterpret_u8_u32(vzip_u32(
1858 vreinterpret_u32_u8(vld1_dup_u8(from+2)),
1859 vreinterpret_u32_u8(vld1_dup_u8(from+3))).val[0]);
1860 return vcombine_u8(
a,
b);
1863 {
return vcombine_s16(vld1_dup_s16(from), vld1_dup_s16(from+1)); }
1865 {
return vcombine_u16(vld1_dup_u16(from), vld1_dup_u16(from+1)); }
1874 { memcpy(to, &from,
sizeof(from)); }
1880 { memcpy(to, &from,
sizeof(from)); }
1911 { memcpy(to, &from,
sizeof(from)); }
1917 { memcpy(to, &from,
sizeof(from)); }
1946 res = vld1_lane_f32(from + 1*stride,
res, 1);
1952 res = vld1q_lane_f32(from + 1*stride,
res, 1);
1953 res = vld1q_lane_f32(from + 2*stride,
res, 2);
1954 res = vld1q_lane_f32(from + 3*stride,
res, 3);
1960 for (
int i = 0;
i != 4;
i++)
1961 reinterpret_cast<int8_t*
>(&
res)[
i] = *(from +
i * stride);
1967 res = vld1_lane_s8(from + 1*stride,
res, 1);
1968 res = vld1_lane_s8(from + 2*stride,
res, 2);
1969 res = vld1_lane_s8(from + 3*stride,
res, 3);
1970 res = vld1_lane_s8(from + 4*stride,
res, 4);
1971 res = vld1_lane_s8(from + 5*stride,
res, 5);
1972 res = vld1_lane_s8(from + 6*stride,
res, 6);
1973 res = vld1_lane_s8(from + 7*stride,
res, 7);
1979 res = vld1q_lane_s8(from + 1*stride,
res, 1);
1980 res = vld1q_lane_s8(from + 2*stride,
res, 2);
1981 res = vld1q_lane_s8(from + 3*stride,
res, 3);
1982 res = vld1q_lane_s8(from + 4*stride,
res, 4);
1983 res = vld1q_lane_s8(from + 5*stride,
res, 5);
1984 res = vld1q_lane_s8(from + 6*stride,
res, 6);
1985 res = vld1q_lane_s8(from + 7*stride,
res, 7);
1986 res = vld1q_lane_s8(from + 8*stride,
res, 8);
1987 res = vld1q_lane_s8(from + 9*stride,
res, 9);
1988 res = vld1q_lane_s8(from + 10*stride,
res, 10);
1989 res = vld1q_lane_s8(from + 11*stride,
res, 11);
1990 res = vld1q_lane_s8(from + 12*stride,
res, 12);
1991 res = vld1q_lane_s8(from + 13*stride,
res, 13);
1992 res = vld1q_lane_s8(from + 14*stride,
res, 14);
1993 res = vld1q_lane_s8(from + 15*stride,
res, 15);
1999 for (
int i = 0;
i != 4;
i++)
2000 reinterpret_cast<uint8_t*
>(&
res)[
i] = *(from +
i * stride);
2006 res = vld1_lane_u8(from + 1*stride,
res, 1);
2007 res = vld1_lane_u8(from + 2*stride,
res, 2);
2008 res = vld1_lane_u8(from + 3*stride,
res, 3);
2009 res = vld1_lane_u8(from + 4*stride,
res, 4);
2010 res = vld1_lane_u8(from + 5*stride,
res, 5);
2011 res = vld1_lane_u8(from + 6*stride,
res, 6);
2012 res = vld1_lane_u8(from + 7*stride,
res, 7);
2018 res = vld1q_lane_u8(from + 1*stride,
res, 1);
2019 res = vld1q_lane_u8(from + 2*stride,
res, 2);
2020 res = vld1q_lane_u8(from + 3*stride,
res, 3);
2021 res = vld1q_lane_u8(from + 4*stride,
res, 4);
2022 res = vld1q_lane_u8(from + 5*stride,
res, 5);
2023 res = vld1q_lane_u8(from + 6*stride,
res, 6);
2024 res = vld1q_lane_u8(from + 7*stride,
res, 7);
2025 res = vld1q_lane_u8(from + 8*stride,
res, 8);
2026 res = vld1q_lane_u8(from + 9*stride,
res, 9);
2027 res = vld1q_lane_u8(from + 10*stride,
res, 10);
2028 res = vld1q_lane_u8(from + 11*stride,
res, 11);
2029 res = vld1q_lane_u8(from + 12*stride,
res, 12);
2030 res = vld1q_lane_u8(from + 13*stride,
res, 13);
2031 res = vld1q_lane_u8(from + 14*stride,
res, 14);
2032 res = vld1q_lane_u8(from + 15*stride,
res, 15);
2038 res = vld1_lane_s16(from + 1*stride,
res, 1);
2039 res = vld1_lane_s16(from + 2*stride,
res, 2);
2040 res = vld1_lane_s16(from + 3*stride,
res, 3);
2046 res = vld1q_lane_s16(from + 1*stride,
res, 1);
2047 res = vld1q_lane_s16(from + 2*stride,
res, 2);
2048 res = vld1q_lane_s16(from + 3*stride,
res, 3);
2049 res = vld1q_lane_s16(from + 4*stride,
res, 4);
2050 res = vld1q_lane_s16(from + 5*stride,
res, 5);
2051 res = vld1q_lane_s16(from + 6*stride,
res, 6);
2052 res = vld1q_lane_s16(from + 7*stride,
res, 7);
2058 res = vld1_lane_u16(from + 1*stride,
res, 1);
2059 res = vld1_lane_u16(from + 2*stride,
res, 2);
2060 res = vld1_lane_u16(from + 3*stride,
res, 3);
2066 res = vld1q_lane_u16(from + 1*stride,
res, 1);
2067 res = vld1q_lane_u16(from + 2*stride,
res, 2);
2068 res = vld1q_lane_u16(from + 3*stride,
res, 3);
2069 res = vld1q_lane_u16(from + 4*stride,
res, 4);
2070 res = vld1q_lane_u16(from + 5*stride,
res, 5);
2071 res = vld1q_lane_u16(from + 6*stride,
res, 6);
2072 res = vld1q_lane_u16(from + 7*stride,
res, 7);
2078 res = vld1_lane_s32(from + 1*stride,
res, 1);
2084 res = vld1q_lane_s32(from + 1*stride,
res, 1);
2085 res = vld1q_lane_s32(from + 2*stride,
res, 2);
2086 res = vld1q_lane_s32(from + 3*stride,
res, 3);
2092 res = vld1_lane_u32(from + 1*stride,
res, 1);
2098 res = vld1q_lane_u32(from + 1*stride,
res, 1);
2099 res = vld1q_lane_u32(from + 2*stride,
res, 2);
2100 res = vld1q_lane_u32(from + 3*stride,
res, 3);
2106 res = vld1q_lane_s64(from + 1*stride,
res, 1);
2112 res = vld1q_lane_u64(from + 1*stride,
res, 1);
2118 vst1_lane_f32(to + stride*0, from, 0);
2119 vst1_lane_f32(to + stride*1, from, 1);
2123 vst1q_lane_f32(to + stride*0, from, 0);
2124 vst1q_lane_f32(to + stride*1, from, 1);
2125 vst1q_lane_f32(to + stride*2, from, 2);
2126 vst1q_lane_f32(to + stride*3, from, 3);
2130 for (
int i = 0;
i != 4;
i++)
2131 *(to +
i * stride) =
reinterpret_cast<const int8_t*
>(&from)[
i];
2135 vst1_lane_s8(to + stride*0, from, 0);
2136 vst1_lane_s8(to + stride*1, from, 1);
2137 vst1_lane_s8(to + stride*2, from, 2);
2138 vst1_lane_s8(to + stride*3, from, 3);
2139 vst1_lane_s8(to + stride*4, from, 4);
2140 vst1_lane_s8(to + stride*5, from, 5);
2141 vst1_lane_s8(to + stride*6, from, 6);
2142 vst1_lane_s8(to + stride*7, from, 7);
2146 vst1q_lane_s8(to + stride*0, from, 0);
2147 vst1q_lane_s8(to + stride*1, from, 1);
2148 vst1q_lane_s8(to + stride*2, from, 2);
2149 vst1q_lane_s8(to + stride*3, from, 3);
2150 vst1q_lane_s8(to + stride*4, from, 4);
2151 vst1q_lane_s8(to + stride*5, from, 5);
2152 vst1q_lane_s8(to + stride*6, from, 6);
2153 vst1q_lane_s8(to + stride*7, from, 7);
2154 vst1q_lane_s8(to + stride*8, from, 8);
2155 vst1q_lane_s8(to + stride*9, from, 9);
2156 vst1q_lane_s8(to + stride*10, from, 10);
2157 vst1q_lane_s8(to + stride*11, from, 11);
2158 vst1q_lane_s8(to + stride*12, from, 12);
2159 vst1q_lane_s8(to + stride*13, from, 13);
2160 vst1q_lane_s8(to + stride*14, from, 14);
2161 vst1q_lane_s8(to + stride*15, from, 15);
2165 for (
int i = 0;
i != 4;
i++)
2166 *(to +
i * stride) =
reinterpret_cast<const uint8_t*
>(&from)[
i];
2170 vst1_lane_u8(to + stride*0, from, 0);
2171 vst1_lane_u8(to + stride*1, from, 1);
2172 vst1_lane_u8(to + stride*2, from, 2);
2173 vst1_lane_u8(to + stride*3, from, 3);
2174 vst1_lane_u8(to + stride*4, from, 4);
2175 vst1_lane_u8(to + stride*5, from, 5);
2176 vst1_lane_u8(to + stride*6, from, 6);
2177 vst1_lane_u8(to + stride*7, from, 7);
2181 vst1q_lane_u8(to + stride*0, from, 0);
2182 vst1q_lane_u8(to + stride*1, from, 1);
2183 vst1q_lane_u8(to + stride*2, from, 2);
2184 vst1q_lane_u8(to + stride*3, from, 3);
2185 vst1q_lane_u8(to + stride*4, from, 4);
2186 vst1q_lane_u8(to + stride*5, from, 5);
2187 vst1q_lane_u8(to + stride*6, from, 6);
2188 vst1q_lane_u8(to + stride*7, from, 7);
2189 vst1q_lane_u8(to + stride*8, from, 8);
2190 vst1q_lane_u8(to + stride*9, from, 9);
2191 vst1q_lane_u8(to + stride*10, from, 10);
2192 vst1q_lane_u8(to + stride*11, from, 11);
2193 vst1q_lane_u8(to + stride*12, from, 12);
2194 vst1q_lane_u8(to + stride*13, from, 13);
2195 vst1q_lane_u8(to + stride*14, from, 14);
2196 vst1q_lane_u8(to + stride*15, from, 15);
2200 vst1_lane_s16(to + stride*0, from, 0);
2201 vst1_lane_s16(to + stride*1, from, 1);
2202 vst1_lane_s16(to + stride*2, from, 2);
2203 vst1_lane_s16(to + stride*3, from, 3);
2207 vst1q_lane_s16(to + stride*0, from, 0);
2208 vst1q_lane_s16(to + stride*1, from, 1);
2209 vst1q_lane_s16(to + stride*2, from, 2);
2210 vst1q_lane_s16(to + stride*3, from, 3);
2211 vst1q_lane_s16(to + stride*4, from, 4);
2212 vst1q_lane_s16(to + stride*5, from, 5);
2213 vst1q_lane_s16(to + stride*6, from, 6);
2214 vst1q_lane_s16(to + stride*7, from, 7);
2218 vst1_lane_u16(to + stride*0, from, 0);
2219 vst1_lane_u16(to + stride*1, from, 1);
2220 vst1_lane_u16(to + stride*2, from, 2);
2221 vst1_lane_u16(to + stride*3, from, 3);
2225 vst1q_lane_u16(to + stride*0, from, 0);
2226 vst1q_lane_u16(to + stride*1, from, 1);
2227 vst1q_lane_u16(to + stride*2, from, 2);
2228 vst1q_lane_u16(to + stride*3, from, 3);
2229 vst1q_lane_u16(to + stride*4, from, 4);
2230 vst1q_lane_u16(to + stride*5, from, 5);
2231 vst1q_lane_u16(to + stride*6, from, 6);
2232 vst1q_lane_u16(to + stride*7, from, 7);
2236 vst1_lane_s32(to + stride*0, from, 0);
2237 vst1_lane_s32(to + stride*1, from, 1);
2241 vst1q_lane_s32(to + stride*0, from, 0);
2242 vst1q_lane_s32(to + stride*1, from, 1);
2243 vst1q_lane_s32(to + stride*2, from, 2);
2244 vst1q_lane_s32(to + stride*3, from, 3);
2248 vst1_lane_u32(to + stride*0, from, 0);
2249 vst1_lane_u32(to + stride*1, from, 1);
2253 vst1q_lane_u32(to + stride*0, from, 0);
2254 vst1q_lane_u32(to + stride*1, from, 1);
2255 vst1q_lane_u32(to + stride*2, from, 2);
2256 vst1q_lane_u32(to + stride*3, from, 3);
2260 vst1q_lane_s64(to + stride*0, from, 0);
2261 vst1q_lane_s64(to + stride*1, from, 1);
2265 vst1q_lane_u64(to + stride*0, from, 0);
2266 vst1q_lane_u64(to + stride*1, from, 1);
2301 const float32x4_t a_r64 = vrev64q_f32(
a);
2302 return vcombine_f32(vget_high_f32(a_r64), vget_low_f32(a_r64));
2305 {
return vget_lane_s32(vreinterpret_s32_s8(vrev64_s8(vreinterpret_s8_s32(vdup_n_s32(
a)))), 0); }
2309 const int8x16_t a_r64 = vrev64q_s8(
a);
2310 return vcombine_s8(vget_high_s8(a_r64), vget_low_s8(a_r64));
2313 {
return vget_lane_u32(vreinterpret_u32_u8(vrev64_u8(vreinterpret_u8_u32(vdup_n_u32(
a)))), 0); }
2317 const uint8x16_t a_r64 = vrev64q_u8(
a);
2318 return vcombine_u8(vget_high_u8(a_r64), vget_low_u8(a_r64));
2323 const int16x8_t a_r64 = vrev64q_s16(
a);
2324 return vcombine_s16(vget_high_s16(a_r64), vget_low_s16(a_r64));
2329 const uint16x8_t a_r64 = vrev64q_u16(
a);
2330 return vcombine_u16(vget_high_u16(a_r64), vget_low_u16(a_r64));
2335 const int32x4_t a_r64 = vrev64q_s32(
a);
2336 return vcombine_s32(vget_high_s32(a_r64), vget_low_s32(a_r64));
2341 const uint32x4_t a_r64 = vrev64q_u32(
a);
2342 return vcombine_u32(vget_high_u32(a_r64), vget_low_u32(a_r64));
2345 {
return vcombine_s64(vget_high_s64(
a), vget_low_s64(
a)); }
2347 {
return vcombine_u64(vget_high_u64(
a), vget_low_u64(
a)); }
2352 {
return vget_lane_s32(vreinterpret_s32_s8(vabs_s8(vreinterpret_s8_s32(vdup_n_s32(
a)))), 0); }
2367 #if EIGEN_ARCH_ARM64
2368 return vabsq_s64(
a);
2370 return vcombine_s64(
2371 vdup_n_s64((
std::abs)(vgetq_lane_s64(
a, 0))),
2372 vdup_n_s64((
std::abs)(vgetq_lane_s64(
a, 1))));
2390 const float32x2_t sum = vadd_f32(vget_low_f32(
a), vget_high_f32(
a));
2391 return vget_lane_f32(vpadd_f32(sum, sum), 0);
2395 const int8x8_t a_dup = vreinterpret_s8_s32(vdup_n_s32(
a));
2396 int8x8_t sum = vpadd_s8(a_dup, a_dup);
2397 sum = vpadd_s8(sum, sum);
2398 return vget_lane_s8(sum, 0);
2402 int8x8_t sum = vpadd_s8(
a,
a);
2403 sum = vpadd_s8(sum, sum);
2404 sum = vpadd_s8(sum, sum);
2405 return vget_lane_s8(sum, 0);
2409 int8x8_t sum = vadd_s8(vget_low_s8(
a), vget_high_s8(
a));
2410 sum = vpadd_s8(sum, sum);
2411 sum = vpadd_s8(sum, sum);
2412 sum = vpadd_s8(sum, sum);
2413 return vget_lane_s8(sum, 0);
2417 const uint8x8_t a_dup = vreinterpret_u8_u32(vdup_n_u32(
a));
2418 uint8x8_t sum = vpadd_u8(a_dup, a_dup);
2419 sum = vpadd_u8(sum, sum);
2420 return vget_lane_u8(sum, 0);
2424 uint8x8_t sum = vpadd_u8(
a,
a);
2425 sum = vpadd_u8(sum, sum);
2426 sum = vpadd_u8(sum, sum);
2427 return vget_lane_u8(sum, 0);
2431 uint8x8_t sum = vadd_u8(vget_low_u8(
a), vget_high_u8(
a));
2432 sum = vpadd_u8(sum, sum);
2433 sum = vpadd_u8(sum, sum);
2434 sum = vpadd_u8(sum, sum);
2435 return vget_lane_u8(sum, 0);
2439 const int16x4_t sum = vpadd_s16(
a,
a);
2440 return vget_lane_s16(vpadd_s16(sum, sum), 0);
2444 int16x4_t sum = vadd_s16(vget_low_s16(
a), vget_high_s16(
a));
2445 sum = vpadd_s16(sum, sum);
2446 sum = vpadd_s16(sum, sum);
2447 return vget_lane_s16(sum, 0);
2451 const uint16x4_t sum = vpadd_u16(
a,
a);
2452 return vget_lane_u16(vpadd_u16(sum, sum), 0);
2456 uint16x4_t sum = vadd_u16(vget_low_u16(
a), vget_high_u16(
a));
2457 sum = vpadd_u16(sum, sum);
2458 sum = vpadd_u16(sum, sum);
2459 return vget_lane_u16(sum, 0);
2464 const int32x2_t sum = vadd_s32(vget_low_s32(
a), vget_high_s32(
a));
2465 return vget_lane_s32(vpadd_s32(sum, sum), 0);
2470 const uint32x2_t sum = vadd_u32(vget_low_u32(
a), vget_high_u32(
a));
2471 return vget_lane_u32(vpadd_u32(sum, sum), 0);
2474 {
return vgetq_lane_s64(
a, 0) + vgetq_lane_s64(
a, 1); }
2476 {
return vgetq_lane_u64(
a, 0) + vgetq_lane_u64(
a, 1); }
2480 return vget_lane_s32(vreinterpret_s32_s8(vadd_s8(
a,
2481 vreinterpret_s8_s32(vrev64_s32(vreinterpret_s32_s8(
a))))), 0);
2484 {
return vadd_s8(vget_high_s8(
a), vget_low_s8(
a)); }
2487 return vget_lane_u32(vreinterpret_u32_u8(vadd_u8(
a,
2488 vreinterpret_u8_u32(vrev64_u32(vreinterpret_u32_u8(
a))))), 0);
2491 {
return vadd_u8(vget_high_u8(
a), vget_low_u8(
a)); }
2493 {
return vadd_s16(vget_high_s16(
a), vget_low_s16(
a)); }
2495 {
return vadd_u16(vget_high_u16(
a), vget_low_u16(
a)); }
2500 {
return vget_lane_f32(
a, 0) * vget_lane_f32(
a, 1); }
2502 {
return predux_mul(vmul_f32(vget_low_f32(
a), vget_high_f32(
a))); }
2505 int8x8_t
prod = vreinterpret_s8_s32(vdup_n_s32(
a));
2507 return vget_lane_s8(
prod, 0) * vget_lane_s8(
prod, 2);
2511 int8x8_t
prod = vmul_s8(
a, vrev16_s8(
a));
2513 return vget_lane_s8(
prod, 0) * vget_lane_s8(
prod, 4);
2516 {
return predux_mul(vmul_s8(vget_low_s8(
a), vget_high_s8(
a))); }
2519 uint8x8_t
prod = vreinterpret_u8_u32(vdup_n_u32(
a));
2521 return vget_lane_u8(
prod, 0) * vget_lane_u8(
prod, 2);
2525 uint8x8_t
prod = vmul_u8(
a, vrev16_u8(
a));
2527 return vget_lane_u8(
prod, 0) * vget_lane_u8(
prod, 4);
2530 {
return predux_mul(vmul_u8(vget_low_u8(
a), vget_high_u8(
a))); }
2533 const int16x4_t
prod = vmul_s16(
a, vrev32_s16(
a));
2534 return vget_lane_s16(
prod, 0) * vget_lane_s16(
prod, 2);
2541 prod = vmul_s16(vget_low_s16(
a), vget_high_s16(
a));
2545 return vget_lane_s16(
prod, 0) * vget_lane_s16(
prod, 2);
2549 const uint16x4_t
prod = vmul_u16(
a, vrev32_u16(
a));
2550 return vget_lane_u16(
prod, 0) * vget_lane_u16(
prod, 2);
2557 prod = vmul_u16(vget_low_u16(
a), vget_high_u16(
a));
2561 return vget_lane_u16(
prod, 0) * vget_lane_u16(
prod, 2);
2564 {
return vget_lane_s32(
a, 0) * vget_lane_s32(
a, 1); }
2566 {
return predux_mul(vmul_s32(vget_low_s32(
a), vget_high_s32(
a))); }
2568 {
return vget_lane_u32(
a, 0) * vget_lane_u32(
a, 1); }
2570 {
return predux_mul(vmul_u32(vget_low_u32(
a), vget_high_u32(
a))); }
2572 {
return vgetq_lane_s64(
a, 0) * vgetq_lane_s64(
a, 1); }
2574 {
return vgetq_lane_u64(
a, 0) * vgetq_lane_u64(
a, 1); }
2578 {
return vget_lane_f32(vpmin_f32(
a,
a), 0); }
2581 const float32x2_t
min = vmin_f32(vget_low_f32(
a), vget_high_f32(
a));
2582 return vget_lane_f32(vpmin_f32(
min,
min), 0);
2586 const int8x8_t a_dup = vreinterpret_s8_s32(vdup_n_s32(
a));
2587 int8x8_t
min = vpmin_s8(a_dup, a_dup);
2589 return vget_lane_s8(
min, 0);
2593 int8x8_t
min = vpmin_s8(
a,
a);
2596 return vget_lane_s8(
min, 0);
2600 int8x8_t
min = vmin_s8(vget_low_s8(
a), vget_high_s8(
a));
2604 return vget_lane_s8(
min, 0);
2608 const uint8x8_t a_dup = vreinterpret_u8_u32(vdup_n_u32(
a));
2609 uint8x8_t
min = vpmin_u8(a_dup, a_dup);
2611 return vget_lane_u8(
min, 0);
2615 uint8x8_t
min = vpmin_u8(
a,
a);
2618 return vget_lane_u8(
min, 0);
2622 uint8x8_t
min = vmin_u8(vget_low_u8(
a), vget_high_u8(
a));
2626 return vget_lane_u8(
min, 0);
2630 const int16x4_t
min = vpmin_s16(
a,
a);
2631 return vget_lane_s16(vpmin_s16(
min,
min), 0);
2635 int16x4_t
min = vmin_s16(vget_low_s16(
a), vget_high_s16(
a));
2638 return vget_lane_s16(
min, 0);
2642 const uint16x4_t
min = vpmin_u16(
a,
a);
2643 return vget_lane_u16(vpmin_u16(
min,
min), 0);
2647 uint16x4_t
min = vmin_u16(vget_low_u16(
a), vget_high_u16(
a));
2650 return vget_lane_u16(
min, 0);
2653 {
return vget_lane_s32(vpmin_s32(
a,
a), 0); }
2656 const int32x2_t
min = vmin_s32(vget_low_s32(
a), vget_high_s32(
a));
2657 return vget_lane_s32(vpmin_s32(
min,
min), 0);
2660 {
return vget_lane_u32(vpmin_u32(
a,
a), 0); }
2663 const uint32x2_t
min = vmin_u32(vget_low_u32(
a), vget_high_u32(
a));
2664 return vget_lane_u32(vpmin_u32(
min,
min), 0);
2667 {
return (
std::min)(vgetq_lane_s64(
a, 0), vgetq_lane_s64(
a, 1)); }
2669 {
return (
std::min)(vgetq_lane_u64(
a, 0), vgetq_lane_u64(
a, 1)); }
2673 {
return vget_lane_f32(vpmax_f32(
a,
a), 0); }
2676 const float32x2_t
max = vmax_f32(vget_low_f32(
a), vget_high_f32(
a));
2677 return vget_lane_f32(vpmax_f32(
max,
max), 0);
2681 const int8x8_t a_dup = vreinterpret_s8_s32(vdup_n_s32(
a));
2682 int8x8_t
max = vpmax_s8(a_dup, a_dup);
2684 return vget_lane_s8(
max, 0);
2688 int8x8_t
max = vpmax_s8(
a,
a);
2691 return vget_lane_s8(
max, 0);
2695 int8x8_t
max = vmax_s8(vget_low_s8(
a), vget_high_s8(
a));
2699 return vget_lane_s8(
max, 0);
2703 const uint8x8_t a_dup = vreinterpret_u8_u32(vdup_n_u32(
a));
2704 uint8x8_t
max = vpmax_u8(a_dup, a_dup);
2706 return vget_lane_u8(
max, 0);
2710 uint8x8_t
max = vpmax_u8(
a,
a);
2713 return vget_lane_u8(
max, 0);
2717 uint8x8_t
max = vmax_u8(vget_low_u8(
a), vget_high_u8(
a));
2721 return vget_lane_u8(
max, 0);
2725 const int16x4_t
max = vpmax_s16(
a,
a);
2726 return vget_lane_s16(vpmax_s16(
max,
max), 0);
2730 int16x4_t
max = vmax_s16(vget_low_s16(
a), vget_high_s16(
a));
2733 return vget_lane_s16(
max, 0);
2737 const uint16x4_t
max = vpmax_u16(
a,
a);
2738 return vget_lane_u16(vpmax_u16(
max,
max), 0);
2742 uint16x4_t
max = vmax_u16(vget_low_u16(
a), vget_high_u16(
a));
2745 return vget_lane_u16(
max, 0);
2748 {
return vget_lane_s32(vpmax_s32(
a,
a), 0); }
2751 const int32x2_t
max = vmax_s32(vget_low_s32(
a), vget_high_s32(
a));
2752 return vget_lane_s32(vpmax_s32(
max,
max), 0);
2755 {
return vget_lane_u32(vpmax_u32(
a,
a), 0); }
2758 const uint32x2_t
max = vmax_u32(vget_low_u32(
a), vget_high_u32(
a));
2759 return vget_lane_u32(vpmax_u32(
max,
max), 0);
2762 {
return (
std::max)(vgetq_lane_s64(
a, 0), vgetq_lane_s64(
a, 1)); }
2764 {
return (
std::max)(vgetq_lane_u64(
a, 0), vgetq_lane_u64(
a, 1)); }
2768 uint32x2_t tmp = vorr_u32(vget_low_u32( vreinterpretq_u32_f32(
x)),
2769 vget_high_u32(vreinterpretq_u32_f32(
x)));
2770 return vget_lane_u32(vpmax_u32(tmp, tmp), 0);
2776 template<
typename Packet>
2781 const float32x2x2_t tmp = vzip_f32(
p1,
p2);
2788 const float32x4x2_t tmp = vzipq_f32(
p1,
p2);
2795 const int8x8x2_t tmp = vzip_s8(
p1,
p2);
2802 const int8x16x2_t tmp = vzipq_s8(
p1,
p2);
2809 const uint8x8x2_t tmp = vzip_u8(
p1,
p2);
2816 const uint8x16x2_t tmp = vzipq_u8(
p1,
p2);
2823 const int32x2x2_t tmp = vzip_s32(
p1,
p2);
2830 const int32x4x2_t tmp = vzipq_s32(
p1,
p2);
2837 const uint32x2x2_t tmp = vzip_u32(
p1,
p2);
2844 const uint32x4x2_t tmp = vzipq_u32(
p1,
p2);
2851 const int16x4x2_t tmp = vzip_s16(
p1,
p2);
2858 const int16x8x2_t tmp = vzipq_s16(
p1,
p2);
2865 const uint16x4x2_t tmp = vzip_u16(
p1,
p2);
2872 const uint16x8x2_t tmp = vzipq_u16(
p1,
p2);
2877 template<
typename Packet>
2882 template<
typename Packet>
2890 template<
typename Packet>
2908 template<
typename Packet>
2911 for (
int i=0;
i<4; ++
i) {
2912 const int m = (1 <<
i);
2914 for (
int j=0;
j<
m; ++
j) {
2915 const int n = (1 << (3-
i));
2917 for (
int k=0; k<
n; ++k) {
2918 const int idx = 2*
j*
n+k;
2936 const int8x8_t
a = vreinterpret_s8_s32(vset_lane_s32(kernel.
packet[2], vdup_n_s32(kernel.
packet[0]), 1));
2937 const int8x8_t
b = vreinterpret_s8_s32(vset_lane_s32(kernel.
packet[3], vdup_n_s32(kernel.
packet[1]), 1));
2939 const int8x8x2_t zip8 = vzip_s8(
a,
b);
2940 const int16x4x2_t zip16 = vzip_s16(vreinterpret_s16_s8(zip8.val[0]), vreinterpret_s16_s8(zip8.val[1]));
2942 kernel.
packet[0] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[0]), 0);
2943 kernel.
packet[1] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[0]), 1);
2944 kernel.
packet[2] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[1]), 0);
2945 kernel.
packet[3] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[1]), 1);
2965 const uint8x8_t
a = vreinterpret_u8_u32(vset_lane_u32(kernel.
packet[2], vdup_n_u32(kernel.
packet[0]), 1));
2966 const uint8x8_t
b = vreinterpret_u8_u32(vset_lane_u32(kernel.
packet[3], vdup_n_u32(kernel.
packet[1]), 1));
2968 const uint8x8x2_t zip8 = vzip_u8(
a,
b);
2969 const uint16x4x2_t zip16 = vzip_u16(vreinterpret_u16_u8(zip8.val[0]), vreinterpret_u16_u8(zip8.val[1]));
2971 kernel.
packet[0] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[0]), 0);
2972 kernel.
packet[1] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[0]), 1);
2973 kernel.
packet[2] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[1]), 0);
2974 kernel.
packet[3] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[1]), 1);
3028 #if EIGEN_ARCH_ARM64
3029 const int64x2_t tmp1 = vzip1q_s64(kernel.
packet[0], kernel.
packet[1]);
3033 const int64x1_t tmp[2][2] = {
3034 { vget_low_s64(kernel.
packet[0]), vget_high_s64(kernel.
packet[0]) },
3035 { vget_low_s64(kernel.
packet[1]), vget_high_s64(kernel.
packet[1]) }
3038 kernel.
packet[0] = vcombine_s64(tmp[0][0], tmp[1][0]);
3039 kernel.
packet[1] = vcombine_s64(tmp[0][1], tmp[1][1]);
3045 #if EIGEN_ARCH_ARM64
3046 const uint64x2_t tmp1 = vzip1q_u64(kernel.
packet[0], kernel.
packet[1]);
3050 const uint64x1_t tmp[2][2] = {
3051 { vget_low_u64(kernel.
packet[0]), vget_high_u64(kernel.
packet[0]) },
3052 { vget_low_u64(kernel.
packet[1]), vget_high_u64(kernel.
packet[1]) }
3055 kernel.
packet[0] = vcombine_u64(tmp[0][0], tmp[1][0]);
3056 kernel.
packet[1] = vcombine_u64(tmp[0][1], tmp[1][1]);
3061 {
return vbsl_f32(vreinterpret_u32_f32(mask),
a,
b); }
3063 {
return vbslq_f32(vreinterpretq_u32_f32(mask),
a,
b); }
3065 {
return vbsl_s8(vreinterpret_u8_s8(mask),
a,
b); }
3067 {
return vbslq_s8(vreinterpretq_u8_s8(mask),
a,
b); }
3069 {
return vbsl_u8(mask,
a,
b); }
3071 {
return vbslq_u8(mask,
a,
b); }
3073 {
return vbsl_s16(vreinterpret_u16_s16(mask),
a,
b); }
3075 {
return vbslq_s16(vreinterpretq_u16_s16(mask),
a,
b); }
3077 {
return vbsl_u16(mask,
a,
b); }
3079 {
return vbslq_u16(mask,
a,
b); }
3081 {
return vbsl_s32(vreinterpret_u32_s32(mask),
a,
b); }
3083 {
return vbslq_s32(vreinterpretq_u32_s32(mask),
a,
b); }
3085 {
return vbsl_u32(mask,
a,
b); }
3087 {
return vbslq_u32(mask,
a,
b); }
3089 {
return vbslq_s64(vreinterpretq_u64_s64(mask),
a,
b); }
3091 {
return vbslq_u64(mask,
a,
b); }
3094 #if EIGEN_ARCH_ARMV8
3096 {
return vrndn_f32(
a); }
3099 {
return vrndnq_f32(
a); }
3102 {
return vrndm_f32(
a); }
3105 {
return vrndmq_f32(
a); }
3108 {
return vrndp_f32(
a); }
3111 {
return vrndpq_f32(
a); }
3149 mask =
pand(mask, cst_1);
3150 return psub(tmp, mask);
3159 mask =
pand(mask, cst_1);
3160 return psub(tmp, mask);
3169 mask =
pand(mask, cst_1);
3170 return padd(tmp, mask);
3179 mask =
pand(mask, cst_1);
3180 return padd(tmp, mask);
3192 uint8x8_t
x = vreinterpret_u8_u32(vdup_n_u32(
a));
3193 uint8x8_t
res = vdup_n_u8(0);
3194 uint8x8_t
add = vdup_n_u8(0x8);
3195 for (
int i = 0;
i < 4;
i++)
3197 const uint8x8_t temp = vorr_u8(
res,
add);
3198 res = vbsl_u8(vcge_u8(
x, vmul_u8(temp, temp)), temp,
res);
3201 return vget_lane_u32(vreinterpret_u32_u8(
res), 0);
3205 uint8x8_t
res = vdup_n_u8(0);
3206 uint8x8_t
add = vdup_n_u8(0x8);
3207 for (
int i = 0;
i < 4;
i++)
3209 const uint8x8_t temp = vorr_u8(
res,
add);
3210 res = vbsl_u8(vcge_u8(
a, vmul_u8(temp, temp)), temp,
res);
3217 uint8x16_t
res = vdupq_n_u8(0);
3218 uint8x16_t
add = vdupq_n_u8(0x8);
3219 for (
int i = 0;
i < 4;
i++)
3221 const uint8x16_t temp = vorrq_u8(
res,
add);
3222 res = vbslq_u8(vcgeq_u8(
a, vmulq_u8(temp, temp)), temp,
res);
3223 add = vshrq_n_u8(
add, 1);
3229 uint16x4_t
res = vdup_n_u16(0);
3230 uint16x4_t
add = vdup_n_u16(0x80);
3231 for (
int i = 0;
i < 8;
i++)
3233 const uint16x4_t temp = vorr_u16(
res,
add);
3234 res = vbsl_u16(vcge_u16(
a, vmul_u16(temp, temp)), temp,
res);
3235 add = vshr_n_u16(
add, 1);
3241 uint16x8_t
res = vdupq_n_u16(0);
3242 uint16x8_t
add = vdupq_n_u16(0x80);
3243 for (
int i = 0;
i < 8;
i++)
3245 const uint16x8_t temp = vorrq_u16(
res,
add);
3246 res = vbslq_u16(vcgeq_u16(
a, vmulq_u16(temp, temp)), temp,
res);
3247 add = vshrq_n_u16(
add, 1);
3253 uint32x2_t
res = vdup_n_u32(0);
3254 uint32x2_t
add = vdup_n_u32(0x8000);
3255 for (
int i = 0;
i < 16;
i++)
3257 const uint32x2_t temp = vorr_u32(
res,
add);
3258 res = vbsl_u32(vcge_u32(
a, vmul_u32(temp, temp)), temp,
res);
3259 add = vshr_n_u32(
add, 1);
3265 uint32x4_t
res = vdupq_n_u32(0);
3266 uint32x4_t
add = vdupq_n_u32(0x8000);
3267 for (
int i = 0;
i < 16;
i++)
3269 const uint32x4_t temp = vorrq_u32(
res,
add);
3270 res = vbslq_u32(vcgeq_u32(
a, vmulq_u32(temp, temp)), temp,
res);
3271 add = vshrq_n_u32(
add, 1);
3280 x = vmulq_f32(vrsqrtsq_f32(vmulq_f32(
a,
x),
x),
x);
3281 x = vmulq_f32(vrsqrtsq_f32(vmulq_f32(
a,
x),
x),
x);
3290 x = vmul_f32(vrsqrts_f32(vmul_f32(
a,
x),
x),
x);
3291 x = vmul_f32(vrsqrts_f32(vmul_f32(
a,
x),
x),
x);
3297 #if EIGEN_ARCH_ARM64
3381 const uint16x4x2_t tmp = vzip_u16(
p1,
p2);
3394 Packet4ui lsb = vandq_u32(vshrq_n_u32(input, 16), vdupq_n_u32(1));
3397 Packet4ui rounding_bias = vaddq_u32(lsb, vdupq_n_u32(0x7fff));
3400 input = vaddq_u32(input, rounding_bias);
3403 input = vshrq_n_u32(input, 16);
3406 const Packet4ui bf16_nan = vdupq_n_u32(0x7fc0);
3408 input = vbslq_u32(mask, input, bf16_nan);
3411 return vmovn_u32(input);
3416 return reinterpret_cast<Packet4f>(vshlq_n_u32(vmovl_u16(
p), 16));
3420 return vmovn_u32(vreinterpretq_u32_f32(
p));
3518 return pselect<Packet4us>(mask,
a,
b);
3588 return preverse<Packet4us>(
a);
3630 #ifdef __apple_build_version__
3634 #define EIGEN_APPLE_DOUBLE_NEON_BUG (__apple_build_version__ < 6010000)
3636 #define EIGEN_APPLE_DOUBLE_NEON_BUG 0
3639 #if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
3645 template <
typename T> uint64x2_t vreinterpretq_u64_f64(
T a) {
return (uint64x2_t)
a; }
3647 template <
typename T> float64x2_t vreinterpretq_f64_u64(
T a) {
return (float64x2_t)
a; }
3650 typedef float64x1_t Packet1d;
3657 const double*
a =
reinterpret_cast<const double*
>(&
m);
3658 const double*
b =
reinterpret_cast<const double*
>(&
n);
3659 Packet2d res = {*(
a + (mask & 1)), *(
b + ((mask >> 1) & 1))};
3665 return shuffle(
a,
b, mask);
3669 return shuffle(
a,
b, 0);
3673 return shuffle(
a,
b, 3);
3675 #define vec2d_duplane(a, p) \
3676 vdupq_laneq_f64(a, p)
3678 template<>
struct packet_traits<double> : default_packet_traits
3721 template<>
struct unpacket_traits<
Packet2d>
3723 typedef double type;
3740 const double c[] = {0.0,1.0};
3750 const Packet2d mask = {numext::bit_cast<double>(0x8000000000000000ull),0.0};
3762 #ifdef __ARM_FEATURE_FMA
3765 {
return vfmaq_f64(
c,
a,
b); }
3768 {
return vmlaq_f64(
c,
a,
b); }
3773 #ifdef __ARM_FEATURE_NUMERIC_MAXMIN
3789 {
return vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(
a),vreinterpretq_u64_f64(
b))); }
3792 {
return vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(
a),vreinterpretq_u64_f64(
b))); }
3795 {
return vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(
a),vreinterpretq_u64_f64(
b))); }
3798 {
return vreinterpretq_f64_u64(vbicq_u64(vreinterpretq_u64_f64(
a),vreinterpretq_u64_f64(
b))); }
3801 {
return vreinterpretq_f64_u64(vcleq_f64(
a,
b)); }
3804 {
return vreinterpretq_f64_u64(vcltq_f64(
a,
b)); }
3807 {
return vreinterpretq_f64_u32(vmvnq_u32(vreinterpretq_u32_u64(vcgeq_f64(
a,
b)))); }
3810 {
return vreinterpretq_f64_u64(vceqq_f64(
a,
b)); }
3828 res = vld1q_lane_f64(from + 0*stride,
res, 0);
3829 res = vld1q_lane_f64(from + 1*stride,
res, 1);
3835 vst1q_lane_f64(to + stride*0, from, 0);
3836 vst1q_lane_f64(to + stride*1, from, 1);
3845 {
return vcombine_f64(vget_high_f64(
a), vget_low_f64(
a)); }
3849 #if EIGEN_COMP_CLANG && defined(__apple_build_version__)
3852 {
return (vget_low_f64(
a) + vget_high_f64(
a))[0]; }
3855 {
return vget_lane_f64(vget_low_f64(
a) + vget_high_f64(
a), 0); }
3860 #if EIGEN_COMP_CLANG && defined(__apple_build_version__)
3862 {
return (vget_low_f64(
a) * vget_high_f64(
a))[0]; }
3865 {
return vget_lane_f64(vget_low_f64(
a) * vget_high_f64(
a), 0); }
3870 {
return vgetq_lane_f64(vpminq_f64(
a,
a), 0); }
3874 {
return vgetq_lane_f64(vpmaxq_f64(
a,
a), 0); }
3880 const float64x2_t tmp1 = vzip1q_f64(kernel.packet[0], kernel.packet[1]);
3881 const float64x2_t tmp2 = vzip2q_f64(kernel.packet[0], kernel.packet[1]);
3883 kernel.packet[0] = tmp1;
3884 kernel.packet[1] = tmp2;
3888 {
return vbslq_f64(vreinterpretq_u64_f64(mask),
a,
b); }
3891 {
return vrndnq_f64(
a); }
3894 {
return vrndmq_f64(
a); }
3897 {
return vrndpq_f64(
a); }
3906 {
return vreinterpretq_f64_u64(vdupq_n_u64(from)); }
3912 x = vmulq_f64(vrsqrtsq_f64(vmulq_f64(
a,
x),
x),
x);
3913 x = vmulq_f64(vrsqrtsq_f64(vmulq_f64(
a,
x),
x),
x);
3914 x = vmulq_f64(vrsqrtsq_f64(vmulq_f64(
a,
x),
x),
x);
3921 #endif // EIGEN_ARCH_ARM64
3924 #if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
3925 typedef float16x4_t Packet4hf;
3926 typedef float16x8_t Packet8hf;
3929 struct packet_traits<
Eigen::half> : default_packet_traits {
3930 typedef Packet8hf
type;
3931 typedef Packet4hf
half;
3973 struct unpacket_traits<Packet4hf> {
3975 typedef Packet4hf
half;
3986 struct unpacket_traits<Packet8hf> {
3988 typedef Packet4hf
half;
4000 return vadd_f16(vget_low_f16(
a), vget_high_f16(
a));
4005 return vdupq_n_f16(from.
x);
4010 return vdup_n_f16(from.
x);
4015 const float16_t
f[] = {0, 1, 2, 3, 4, 5, 6, 7};
4016 Packet8hf countdown = vld1q_f16(
f);
4017 return vaddq_f16(pset1<Packet8hf>(
a), countdown);
4022 const float16_t
f[] = {0, 1, 2, 3};
4023 Packet4hf countdown = vld1_f16(
f);
4024 return vadd_f16(pset1<Packet4hf>(
a), countdown);
4029 return vaddq_f16(
a,
b);
4034 return vadd_f16(
a,
b);
4039 return vsubq_f16(
a,
b);
4044 return vsub_f16(
a,
b);
4049 return vnegq_f16(
a);
4069 return vmulq_f16(
a,
b);
4074 return vmul_f16(
a,
b);
4079 return vdivq_f16(
a,
b);
4084 return vdiv_f16(
a,
b);
4089 return vfmaq_f16(
c,
a,
b);
4094 return vfma_f16(
c,
a,
b);
4099 return vminq_f16(
a,
b);
4104 return vmin_f16(
a,
b);
4107 #ifdef __ARM_FEATURE_NUMERIC_MAXMIN
4109 template<>
EIGEN_STRONG_INLINE Packet4hf pmin<PropagateNumbers, Packet4hf>(
const Packet4hf&
a,
const Packet4hf&
b) {
return vminnm_f16(
a,
b); }
4110 template<>
EIGEN_STRONG_INLINE Packet8hf pmin<PropagateNumbers, Packet8hf>(
const Packet8hf&
a,
const Packet8hf&
b) {
return vminnmq_f16(
a,
b); }
4113 template<>
EIGEN_STRONG_INLINE Packet4hf pmin<PropagateNaN, Packet4hf>(
const Packet4hf&
a,
const Packet4hf&
b) {
return pmin<Packet4hf>(
a,
b); }
4115 template<>
EIGEN_STRONG_INLINE Packet8hf pmin<PropagateNaN, Packet8hf>(
const Packet8hf&
a,
const Packet8hf&
b) {
return pmin<Packet8hf>(
a,
b); }
4119 return vmaxq_f16(
a,
b);
4124 return vmax_f16(
a,
b);
4127 #ifdef __ARM_FEATURE_NUMERIC_MAXMIN
4129 template<>
EIGEN_STRONG_INLINE Packet4hf pmax<PropagateNumbers, Packet4hf>(
const Packet4hf&
a,
const Packet4hf&
b) {
return vmaxnm_f16(
a,
b); }
4130 template<>
EIGEN_STRONG_INLINE Packet8hf pmax<PropagateNumbers, Packet8hf>(
const Packet8hf&
a,
const Packet8hf&
b) {
return vmaxnmq_f16(
a,
b); }
4133 template<>
EIGEN_STRONG_INLINE Packet4hf pmax<PropagateNaN, Packet4hf>(
const Packet4hf&
a,
const Packet4hf&
b) {
return pmax<Packet4hf>(
a,
b); }
4135 template<>
EIGEN_STRONG_INLINE Packet8hf pmax<PropagateNaN, Packet8hf>(
const Packet8hf&
a,
const Packet8hf&
b) {
return pmax<Packet8hf>(
a,
b); }
4137 #define EIGEN_MAKE_ARM_FP16_CMP_8(name) \
4139 EIGEN_STRONG_INLINE Packet8hf pcmp_##name(const Packet8hf& a, const Packet8hf& b) { \
4140 return vreinterpretq_f16_u16(vc##name##q_f16(a, b)); \
4143 #define EIGEN_MAKE_ARM_FP16_CMP_4(name) \
4145 EIGEN_STRONG_INLINE Packet4hf pcmp_##name(const Packet4hf& a, const Packet4hf& b) { \
4146 return vreinterpret_f16_u16(vc##name##_f16(a, b)); \
4149 EIGEN_MAKE_ARM_FP16_CMP_8(eq)
4150 EIGEN_MAKE_ARM_FP16_CMP_8(lt)
4151 EIGEN_MAKE_ARM_FP16_CMP_8(le)
4153 EIGEN_MAKE_ARM_FP16_CMP_4(eq)
4154 EIGEN_MAKE_ARM_FP16_CMP_4(lt)
4155 EIGEN_MAKE_ARM_FP16_CMP_4(le)
4157 #undef EIGEN_MAKE_ARM_FP16_CMP_8
4158 #undef EIGEN_MAKE_ARM_FP16_CMP_4
4162 return vreinterpretq_f16_u16(vmvnq_u16(vcgeq_f16(
a,
b)));
4167 return vreinterpret_f16_u16(vmvn_u16(vcge_f16(
a,
b)));
4172 {
return vrndnq_f16(
a); }
4176 {
return vrndn_f16(
a); }
4180 {
return vrndmq_f16(
a); }
4184 {
return vrndm_f16(
a); }
4188 {
return vrndpq_f16(
a); }
4192 {
return vrndp_f16(
a); }
4196 return vsqrtq_f16(
a);
4201 return vsqrt_f16(
a);
4206 return vreinterpretq_f16_u16(vandq_u16(vreinterpretq_u16_f16(
a), vreinterpretq_u16_f16(
b)));
4211 return vreinterpret_f16_u16(vand_u16(vreinterpret_u16_f16(
a), vreinterpret_u16_f16(
b)));
4216 return vreinterpretq_f16_u16(vorrq_u16(vreinterpretq_u16_f16(
a), vreinterpretq_u16_f16(
b)));
4221 return vreinterpret_f16_u16(vorr_u16(vreinterpret_u16_f16(
a), vreinterpret_u16_f16(
b)));
4226 return vreinterpretq_f16_u16(veorq_u16(vreinterpretq_u16_f16(
a), vreinterpretq_u16_f16(
b)));
4231 return vreinterpret_f16_u16(veor_u16(vreinterpret_u16_f16(
a), vreinterpret_u16_f16(
b)));
4236 return vreinterpretq_f16_u16(vbicq_u16(vreinterpretq_u16_f16(
a), vreinterpretq_u16_f16(
b)));
4241 return vreinterpret_f16_u16(vbic_u16(vreinterpret_u16_f16(
a), vreinterpret_u16_f16(
b)));
4267 packet[0] = from[0].
x;
4268 packet[1] = from[0].
x;
4269 packet[2] = from[1].
x;
4270 packet[3] = from[1].
x;
4271 packet[4] = from[2].
x;
4272 packet[5] = from[2].
x;
4273 packet[6] = from[3].
x;
4274 packet[7] = from[3].
x;
4282 tmp = (float16_t*)&packet;
4293 lo = vld1_dup_f16(
reinterpret_cast<const float16_t*
>(from));
4294 hi = vld1_dup_f16(
reinterpret_cast<const float16_t*
>(from+1));
4295 return vcombine_f16(lo, hi);
4304 return vbslq_f16(vreinterpretq_u16_f16(mask),
a,
b);
4309 return vbsl_f16(vreinterpret_u16_f16(mask),
a,
b);
4339 res = vsetq_lane_f16(from[0 * stride].
x,
res, 0);
4340 res = vsetq_lane_f16(from[1 * stride].
x,
res, 1);
4341 res = vsetq_lane_f16(from[2 * stride].
x,
res, 2);
4342 res = vsetq_lane_f16(from[3 * stride].
x,
res, 3);
4343 res = vsetq_lane_f16(from[4 * stride].
x,
res, 4);
4344 res = vsetq_lane_f16(from[5 * stride].
x,
res, 5);
4345 res = vsetq_lane_f16(from[6 * stride].
x,
res, 6);
4346 res = vsetq_lane_f16(from[7 * stride].
x,
res, 7);
4353 res = vset_lane_f16(from[0 * stride].
x,
res, 0);
4354 res = vset_lane_f16(from[1 * stride].
x,
res, 1);
4355 res = vset_lane_f16(from[2 * stride].
x,
res, 2);
4356 res = vset_lane_f16(from[3 * stride].
x,
res, 3);
4362 to[stride * 0].
x = vgetq_lane_f16(from, 0);
4363 to[stride * 1].
x = vgetq_lane_f16(from, 1);
4364 to[stride * 2].
x = vgetq_lane_f16(from, 2);
4365 to[stride * 3].
x = vgetq_lane_f16(from, 3);
4366 to[stride * 4].
x = vgetq_lane_f16(from, 4);
4367 to[stride * 5].
x = vgetq_lane_f16(from, 5);
4368 to[stride * 6].
x = vgetq_lane_f16(from, 6);
4369 to[stride * 7].
x = vgetq_lane_f16(from, 7);
4374 to[stride * 0].
x = vget_lane_f16(from, 0);
4375 to[stride * 1].
x = vget_lane_f16(from, 1);
4376 to[stride * 2].
x = vget_lane_f16(from, 2);
4377 to[stride * 3].
x = vget_lane_f16(from, 3);
4404 float16x4_t a_lo, a_hi;
4407 a_r64 = vrev64q_f16(
a);
4408 a_lo = vget_low_f16(a_r64);
4409 a_hi = vget_high_f16(a_r64);
4410 return vcombine_f16(a_hi, a_lo);
4415 return vrev64_f16(
a);
4420 return vabsq_f16(
a);
4430 float16x4_t a_lo, a_hi, sum;
4432 a_lo = vget_low_f16(
a);
4433 a_hi = vget_high_f16(
a);
4434 sum = vpadd_f16(a_lo, a_hi);
4435 sum = vpadd_f16(sum, sum);
4436 sum = vpadd_f16(sum, sum);
4439 h.x = vget_lane_f16(sum, 0);
4447 sum = vpadd_f16(
a,
a);
4448 sum = vpadd_f16(sum, sum);
4450 h.x = vget_lane_f16(sum, 0);
4456 float16x4_t a_lo, a_hi,
prod;
4458 a_lo = vget_low_f16(
a);
4459 a_hi = vget_high_f16(
a);
4460 prod = vmul_f16(a_lo, a_hi);
4464 h.x = vmulh_f16(vget_lane_f16(
prod, 0), vget_lane_f16(
prod, 1));
4471 prod = vmul_f16(
a, vrev64_f16(
a));
4473 h.x = vmulh_f16(vget_lane_f16(
prod, 0), vget_lane_f16(
prod, 1));
4479 float16x4_t a_lo, a_hi,
min;
4481 a_lo = vget_low_f16(
a);
4482 a_hi = vget_high_f16(
a);
4483 min = vpmin_f16(a_lo, a_hi);
4488 h.x = vget_lane_f16(
min, 0);
4495 tmp = vpmin_f16(
a,
a);
4496 tmp = vpmin_f16(tmp, tmp);
4498 h.x = vget_lane_f16(tmp, 0);
4504 float16x4_t a_lo, a_hi,
max;
4506 a_lo = vget_low_f16(
a);
4507 a_hi = vget_high_f16(
a);
4508 max = vpmax_f16(a_lo, a_hi);
4513 h.x = vget_lane_f16(
max, 0);
4520 tmp = vpmax_f16(
a,
a);
4521 tmp = vpmax_f16(tmp, tmp);
4523 h.x = vget_lane_f16(tmp, 0);
4529 const float16x8x2_t zip16_1 = vzipq_f16(kernel.packet[0], kernel.packet[1]);
4530 const float16x8x2_t zip16_2 = vzipq_f16(kernel.packet[2], kernel.packet[3]);
4532 const float32x4x2_t zip32_1 = vzipq_f32(vreinterpretq_f32_f16(zip16_1.val[0]), vreinterpretq_f32_f16(zip16_2.val[0]));
4533 const float32x4x2_t zip32_2 = vzipq_f32(vreinterpretq_f32_f16(zip16_1.val[1]), vreinterpretq_f32_f16(zip16_2.val[1]));
4535 kernel.packet[0] = vreinterpretq_f16_f32(zip32_1.val[0]);
4536 kernel.packet[1] = vreinterpretq_f16_f32(zip32_1.val[1]);
4537 kernel.packet[2] = vreinterpretq_f16_f32(zip32_2.val[0]);
4538 kernel.packet[3] = vreinterpretq_f16_f32(zip32_2.val[1]);
4543 float16_t* tmp = (float16_t*)&kernel;
4544 tmp_x4 = vld4_f16(tmp);
4546 kernel.packet[0] = tmp_x4.val[0];
4547 kernel.packet[1] = tmp_x4.val[1];
4548 kernel.packet[2] = tmp_x4.val[2];
4549 kernel.packet[3] = tmp_x4.val[3];
4553 float16x8x2_t T_1[4];
4555 T_1[0] = vuzpq_f16(kernel.packet[0], kernel.packet[1]);
4556 T_1[1] = vuzpq_f16(kernel.packet[2], kernel.packet[3]);
4557 T_1[2] = vuzpq_f16(kernel.packet[4], kernel.packet[5]);
4558 T_1[3] = vuzpq_f16(kernel.packet[6], kernel.packet[7]);
4560 float16x8x2_t T_2[4];
4561 T_2[0] = vuzpq_f16(T_1[0].val[0], T_1[1].val[0]);
4562 T_2[1] = vuzpq_f16(T_1[0].val[1], T_1[1].val[1]);
4563 T_2[2] = vuzpq_f16(T_1[2].val[0], T_1[3].val[0]);
4564 T_2[3] = vuzpq_f16(T_1[2].val[1], T_1[3].val[1]);
4566 float16x8x2_t T_3[4];
4567 T_3[0] = vuzpq_f16(T_2[0].val[0], T_2[2].val[0]);
4568 T_3[1] = vuzpq_f16(T_2[0].val[1], T_2[2].val[1]);
4569 T_3[2] = vuzpq_f16(T_2[1].val[0], T_2[3].val[0]);
4570 T_3[3] = vuzpq_f16(T_2[1].val[1], T_2[3].val[1]);
4572 kernel.packet[0] = T_3[0].val[0];
4573 kernel.packet[1] = T_3[2].val[0];
4574 kernel.packet[2] = T_3[1].val[0];
4575 kernel.packet[3] = T_3[3].val[0];
4576 kernel.packet[4] = T_3[0].val[1];
4577 kernel.packet[5] = T_3[2].val[1];
4578 kernel.packet[6] = T_3[1].val[1];
4579 kernel.packet[7] = T_3[3].val[1];
4581 #endif // end EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
4587 #endif // EIGEN_PACKET_MATH_NEON_H
EIGEN_STRONG_INLINE int32_t predux_mul< Packet2i >(const Packet2i &a)
EIGEN_STRONG_INLINE Packet8us pxor< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_STRONG_INLINE Packet4f vec4f_unpackhi(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4ui ploadu< Packet4ui >(const uint32_t *from)
EIGEN_STRONG_INLINE Packet4f shuffle2(const Packet4f &m, const Packet4f &n, int mask)
EIGEN_STRONG_INLINE Packet4bf pmin< PropagateNumbers, Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE void pstore< uint16_t >(uint16_t *to, const Packet4us &from)
EIGEN_STRONG_INLINE Packet2f pset1frombits< Packet2f >(unsigned int from)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint64_t, Packet2ul >(uint64_t *to, const Packet2ul &from, Index stride)
EIGEN_STRONG_INLINE Packet4ui pset1< Packet4ui >(const uint32_t &from)
EIGEN_STRONG_INLINE Packet4us pcmp_lt< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_STRONG_INLINE Packet8c ploaddup< Packet8c >(const int8_t *from)
EIGEN_STRONG_INLINE void pstoreu< int16_t >(int16_t *to, const Packet4s &from)
EIGEN_STRONG_INLINE Packet2i por< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE int64_t predux< Packet2l >(const Packet2l &a)
EIGEN_STRONG_INLINE int8_t predux_min< Packet8c >(const Packet8c &a)
EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf &a, const Packet2cf &b)
EIGEN_STRONG_INLINE Packet2d pset1< Packet2d >(const double &from)
EIGEN_STRONG_INLINE Packet4f print(const Packet4f &a)
EIGEN_STRONG_INLINE Packet4c pabsdiff< Packet4c >(const Packet4c &a, const Packet4c &b)
EIGEN_STRONG_INLINE void pstoreu< uint16_t >(uint16_t *to, const Packet4us &from)
EIGEN_STRONG_INLINE Packet4f pcmp_lt< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet2d pdiv< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet4c pmax< Packet4c >(const Packet4c &a, const Packet4c &b)
#define EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Packet2d pmin< PropagateNaN, Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet4uc pload< Packet4uc >(const uint8_t *from)
__vector unsigned char Packet16uc
EIGEN_STRONG_INLINE Packet2ul pmul< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
Namespace containing all symbols from the Eigen library.
EIGEN_STRONG_INLINE Packet4f pset1frombits< Packet4f >(unsigned int from)
EIGEN_STRONG_INLINE Packet4i pcmp_le< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE int16_t predux< Packet4s >(const Packet4s &a)
EIGEN_STRONG_INLINE Packet4uc por< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_STRONG_INLINE Packet8c por< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE Packet4f psqrt(const Packet4f &a)
EIGEN_STRONG_INLINE Packet4c ploadquad< Packet4c >(const int8_t *from)
EIGEN_STRONG_INLINE unsigned char predux_min< Packet16uc >(const Packet16uc &a)
EIGEN_STRONG_INLINE Packet16uc pmax< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE Packet8c psub< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE Packet8s pcmp_lt< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet4s ploadu< Packet4s >(const int16_t *from)
EIGEN_STRONG_INLINE Packet2ul psub< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
EIGEN_STRONG_INLINE Packet2i pxor< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE Packet2d pmul< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet16c ploadquad< Packet16c >(const int8_t *from)
EIGEN_STRONG_INLINE Packet2ul pcmp_lt< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
#define EIGEN_ARM_PREFETCH(ADDR)
EIGEN_STRONG_INLINE Packet4i pxor< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE Packet2d vec2d_unpackhi(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet2ui pandnot< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet16c plset< Packet16c >(const signed char &a)
EIGEN_STRONG_INLINE Packet4i pload< Packet4i >(const int *from)
EIGEN_STRONG_INLINE int8_t predux_mul< Packet8c >(const Packet8c &a)
EIGEN_STRONG_INLINE Packet8us pcmp_eq< Packet8us >(const Packet8us &a, const Packet8us &b)
CleanedUpDerType< DerType >::type() max(const AutoDiffScalar< DerType > &x, const T &y)
EIGEN_STRONG_INLINE int pfirst< Packet4i >(const Packet4i &a)
EIGEN_STRONG_INLINE Packet2ui pset1< Packet2ui >(const uint32_t &from)
EIGEN_STRONG_INLINE Packet8c pmul< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE Packet2ui por< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet8uc pload< Packet8uc >(const uint8_t *from)
EIGEN_STRONG_INLINE Packet8us pmul< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_STRONG_INLINE uint8_t predux_max< Packet8uc >(const Packet8uc &a)
EIGEN_STRONG_INLINE Packet4bf pcmp_eq< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE Packet4f ploadquad< Packet4f >(const float *from)
EIGEN_STRONG_INLINE Packet8c ploadu< Packet8c >(const int8_t *from)
EIGEN_STRONG_INLINE void prefetch< int16_t >(const int16_t *addr)
EIGEN_STRONG_INLINE Packet4s pset1< Packet4s >(const int16_t &from)
EIGEN_STRONG_INLINE Packet4c pload< Packet4c >(const int8_t *from)
EIGEN_STRONG_INLINE Packet4c pcmp_le< Packet4c >(const Packet4c &a, const Packet4c &b)
EIGEN_STRONG_INLINE Packet4bf pgather< bfloat16, Packet4bf >(const bfloat16 *from, Index stride)
EIGEN_STRONG_INLINE Packet4i pand< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE Packet4f paddsub< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c predux_half_dowto4(const Packet8c &a)
EIGEN_STRONG_INLINE Packet4f pldexp< Packet4f >(const Packet4f &a, const Packet4f &exponent)
EIGEN_STRONG_INLINE Packet4us pabsdiff< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_STRONG_INLINE Packet2l padd< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_STRONG_INLINE Packet8uc pandnot< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE Packet16uc pset1< Packet16uc >(const unsigned char &from)
EIGEN_STRONG_INLINE Packet4f pfloor< Packet4f >(const Packet4f &a)
EIGEN_STRONG_INLINE uint16_t predux_min< Packet4us >(const Packet4us &a)
EIGEN_STRONG_INLINE Packet8us ploadquad< Packet8us >(const unsigned short int *from)
EIGEN_STRONG_INLINE Packet2i ploaddup< Packet2i >(const int32_t *from)
EIGEN_STRONG_INLINE Packet4f shuffle1(const Packet4f &m, int mask)
EIGEN_STRONG_INLINE Packet8us pmax< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_STRONG_INLINE Packet4us pdiv< Packet4us >(const Packet4us &, const Packet4us &)
EIGEN_STRONG_INLINE void prefetch< int32_t >(const int32_t *addr)
EIGEN_STRONG_INLINE signed char predux< Packet16c >(const Packet16c &a)
EIGEN_STRONG_INLINE Packet16uc ploadquad< Packet16uc >(const uint8_t *from)
EIGEN_DEVICE_FUNC void pscatter< int32_t, Packet4i >(int32_t *to, const Packet4i &from, Index stride)
EIGEN_STRONG_INLINE double predux_max< Packet2d >(const Packet2d &a)
EIGEN_STRONG_INLINE Packet2ui pabsdiff< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet2d pset1frombits< Packet2d >(uint64_t from)
EIGEN_STRONG_INLINE Packet8c plset< Packet8c >(const int8_t &a)
EIGEN_DEVICE_FUNC Packet4f pgather< float, Packet4f >(const float *from, Index stride)
EIGEN_STRONG_INLINE Packet4ui pcmp_le< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE Packet2l por< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_STRONG_INLINE Packet4c pcmp_eq< Packet4c >(const Packet4c &a, const Packet4c &b)
EIGEN_STRONG_INLINE int16_t predux_mul< Packet4s >(const Packet4s &a)
EIGEN_STRONG_INLINE Packet4bf padd< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE Packet4s pmin< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE Packet2ui pand< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet2f >(Packet2f &p1, Packet2f &p2)
EIGEN_STRONG_INLINE Packet2i pload< Packet2i >(const int32_t *from)
EIGEN_STRONG_INLINE Packet4us pmin< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int8_t, Packet16c >(int8_t *to, const Packet16c &from, Index stride)
EIGEN_STRONG_INLINE Packet4bf pmin< PropagateNaN, Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE Packet2l pxor< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_STRONG_INLINE Packet4f pcmp_lt(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet8s ploadquad< Packet8s >(const short int *from)
EIGEN_STRONG_INLINE Packet8uc pcmp_eq< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint16_t, Packet4us >(uint16_t *to, const Packet4us &from, Index stride)
EIGEN_STRONG_INLINE void pstore< uint8_t >(uint8_t *to, const Packet4uc &from)
EIGEN_STRONG_INLINE int32_t predux< Packet2i >(const Packet2i &a)
EIGEN_STRONG_INLINE void pstore< bfloat16 >(bfloat16 *to, const Packet8bf &from)
EIGEN_STRONG_INLINE Packet8c pandnot< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE Packet2f ploaddup< Packet2f >(const float *from)
EIGEN_STRONG_INLINE Packet4s pcmp_eq< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE Packet4ui por< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE Packet2f pandnot< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __bfloat16_raw raw_uint16_to_bfloat16(unsigned short value)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul pgather< uint64_t, Packet2ul >(const uint64_t *from, Index stride)
EIGEN_STRONG_INLINE Packet2d ploaddup< Packet2d >(const double *from)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s pgather< int16_t, Packet4s >(const int16_t *from, Index stride)
EIGEN_STRONG_INLINE Packet4f psub< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet8uc pxor< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE Packet16uc pxor< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE Packet4i plset< Packet4i >(const int &a)
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
EIGEN_STRONG_INLINE Packet2l pandnot< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_STRONG_INLINE Packet4us pandnot< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_STRONG_INLINE Packet4uc pabsdiff< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_STRONG_INLINE Packet2ul plset< Packet2ul >(const uint64_t &a)
EIGEN_STRONG_INLINE Packet2i ploadu< Packet2i >(const int32_t *from)
EIGEN_STRONG_INLINE Packet4s pabsdiff< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE float predux_mul< Packet2f >(const Packet2f &a)
EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(const Packet4i &a)
EIGEN_STRONG_INLINE unsigned short int predux< Packet8us >(const Packet8us &a)
EIGEN_STRONG_INLINE Packet4s psub< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint8_t, Packet4uc >(uint8_t *to, const Packet4uc &from, Index stride)
EIGEN_STRONG_INLINE unsigned char pfirst< Packet16uc >(const Packet16uc &a)
EIGEN_STRONG_INLINE Packet8uc pcmp_lt< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE Packet4i ploadu< Packet4i >(const int *from)
EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf &a)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet4bf >(Packet4bf &p1, Packet4bf &p2)
EIGEN_STRONG_INLINE Packet4bf pmul< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc pgather< uint8_t, Packet8uc >(const uint8_t *from, Index stride)
EIGEN_STRONG_INLINE int8_t predux_max< Packet4c >(const Packet4c &a)
EIGEN_STRONG_INLINE Packet4us padd< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us pgather< uint16_t, Packet8us >(const uint16_t *from, Index stride)
EIGEN_STRONG_INLINE bfloat16 predux_max< Packet4bf >(const Packet4bf &a)
EIGEN_STRONG_INLINE Packet2l pset1< Packet2l >(const int64_t &from)
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type predux_mul(const Packet &a)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet8uc >(Packet8uc &p1, Packet8uc &p2)
EIGEN_STRONG_INLINE Packet8uc pabsdiff< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE Packet2f pmin< PropagateNaN, Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet8us pandnot< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_STRONG_INLINE void prefetch< uint32_t >(const uint32_t *addr)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i pgather< int32_t, Packet2i >(const int32_t *from, Index stride)
EIGEN_STRONG_INLINE signed char predux_max< Packet16c >(const Packet16c &a)
EIGEN_STRONG_INLINE Packet2l pcmp_le< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_STRONG_INLINE Packet2d pfrexp< Packet2d >(const Packet2d &a, Packet2d &exponent)
EIGEN_STRONG_INLINE Packet2ui pmul< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet4i pandnot< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE Packet4bf pnegate< Packet4bf >(const Packet4bf &a)
EIGEN_STRONG_INLINE Packet2ul pmin< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
EIGEN_STRONG_INLINE Packet2l pand< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_STRONG_INLINE Packet2i pdiv< Packet2i >(const Packet2i &, const Packet2i &)
EIGEN_STRONG_INLINE Packet2d ploadu< Packet2d >(const double *from)
EIGEN_STRONG_INLINE Packet4s plset< Packet4s >(const int16_t &a)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet8s >(Packet8s &p1, Packet8s &p2)
EIGEN_STRONG_INLINE Packet4bf pmax< PropagateNaN, Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint32_t, Packet4ui >(uint32_t *to, const Packet4ui &from, Index stride)
EIGEN_STRONG_INLINE Packet4uc pset1< Packet4uc >(const uint8_t &from)
EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf &a)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet16c >(Packet16c &p1, Packet16c &p2)
EIGEN_STRONG_INLINE Packet4us pload< Packet4us >(const uint16_t *from)
EIGEN_STRONG_INLINE void pstore< int64_t >(int64_t *to, const Packet2l &from)
EIGEN_STRONG_INLINE Packet16c ploaddup< Packet16c >(const signed char *from)
EIGEN_STRONG_INLINE Packet16uc por< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE short int predux_min< Packet8s >(const Packet8s &a)
EIGEN_STRONG_INLINE Packet16c pand< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_STRONG_INLINE Packet8s pcmp_le< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE uint32_t predux_mul< Packet4ui >(const Packet4ui &a)
EIGEN_STRONG_INLINE uint16_t pfirst< Packet4us >(const Packet4us &a)
EIGEN_STRONG_INLINE float predux_max< Packet4f >(const Packet4f &a)
EIGEN_STRONG_INLINE Packet8c ploadquad< Packet8c >(const int8_t *from)
cout<< "Here is the matrix m:"<< endl<< m<< endl;Matrix< ptrdiff_t, 3, 1 > res
EIGEN_STRONG_INLINE Packet2f paddsub< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet4us ploaddup< Packet4us >(const uint16_t *from)
EIGEN_STRONG_INLINE Packet8us ploadu< Packet8us >(const unsigned short int *from)
EIGEN_STRONG_INLINE Packet4bf F32MaskToBf16Mask(const Packet4f &p)
EIGEN_STRONG_INLINE void prefetch< float >(const float *addr)
EIGEN_STRONG_INLINE Packet4f pcmp_le< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4f ploadu< Packet4f >(const float *from)
EIGEN_STRONG_INLINE Packet4bf pmin< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE Packet2ui pcmp_eq< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet8us padd< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_STRONG_INLINE Packet4bf ploadu< Packet4bf >(const bfloat16 *from)
EIGEN_DEVICE_FUNC Packet2d pgather< double, Packet2d >(const double *from, Index stride)
EIGEN_STRONG_INLINE int8_t predux_min< Packet4c >(const Packet4c &a)
EIGEN_STRONG_INLINE int8_t predux_mul< Packet4c >(const Packet4c &a)
EIGEN_STRONG_INLINE Packet4bf pmax< PropagateNumbers, Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE Packet2f padd< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint16_t, Packet8us >(uint16_t *to, const Packet8us &from, Index stride)
EIGEN_STRONG_INLINE unsigned char predux_max< Packet16uc >(const Packet16uc &a)
EIGEN_STRONG_INLINE Packet4us pcmp_eq< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_STRONG_INLINE Packet16uc pabsdiff< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE Packet8us pand< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet8us >(Packet8us &p1, Packet8us &p2)
EIGEN_STRONG_INLINE Packet2ul por< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
EIGEN_STRONG_INLINE Packet4uc padd< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_STRONG_INLINE Packet4uc ploadquad< Packet4uc >(const uint8_t *from)
EIGEN_STRONG_INLINE int8_t predux< Packet8c >(const Packet8c &a)
EIGEN_STRONG_INLINE Packet2d pmin< PropagateNumbers, Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet8uc ploaddup< Packet8uc >(const uint8_t *from)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint8_t, Packet8uc >(uint8_t *to, const Packet8uc &from, Index stride)
EIGEN_STRONG_INLINE Packet8us por< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_STRONG_INLINE Packet8us pabsdiff< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_STRONG_INLINE Packet4us psub< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_STRONG_INLINE Packet8s pcmp_eq< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet2f por< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE signed char predux_mul< Packet16c >(const Packet16c &a)
EIGEN_STRONG_INLINE Packet2d pldexp< Packet2d >(const Packet2d &a, const Packet2d &exponent)
EIGEN_STRONG_INLINE Packet4f pfrexp< Packet4f >(const Packet4f &a, Packet4f &exponent)
EIGEN_STRONG_INLINE Packet2i pmin< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE uint32_t pfirst< Packet4ui >(const Packet4ui &a)
EIGEN_STRONG_INLINE Packet2ui plset< Packet2ui >(const uint32_t &a)
EIGEN_STRONG_INLINE Packet4uc pcmp_lt< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui pgather< uint32_t, Packet4ui >(const uint32_t *from, Index stride)
EIGEN_STRONG_INLINE Packet4f pload< Packet4f >(const float *from)
EIGEN_STRONG_INLINE Packet2d por< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet4bf ploaddup< Packet4bf >(const bfloat16 *from)
EIGEN_STRONG_INLINE Packet8h pxor(const Packet8h &a, const Packet8h &b)
EIGEN_STRONG_INLINE Packet2f pabsdiff< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet4f padd< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet2i plset< Packet2i >(const int32_t &a)
#define EIGEN_DEBUG_UNALIGNED_STORE
EIGEN_STRONG_INLINE Packet4ui pmin< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE uint32_t predux_min< Packet4ui >(const Packet4ui &a)
EIGEN_STRONG_INLINE Packet4f pmax< PropagateNumbers, Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4ui padd< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE Packet4us pcmp_le< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_STRONG_INLINE Packet2ul pcmp_eq< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
EIGEN_STRONG_INLINE Packet4ui pand< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE Packet4s pcmp_le< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE Packet16c padd< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_STRONG_INLINE uint8_t pfirst< Packet4uc >(const Packet4uc &a)
EIGEN_STRONG_INLINE Packet2d pand< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet4c plset< Packet4c >(const int8_t &a)
EIGEN_STRONG_INLINE Packet4f pandnot< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet16c pmul< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_STRONG_INLINE Packet4uc ploaddup< Packet4uc >(const uint8_t *from)
EIGEN_STRONG_INLINE Packet4i psub< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE Packet4c pdiv< Packet4c >(const Packet4c &, const Packet4c &)
EIGEN_STRONG_INLINE void pstore< uint32_t >(uint32_t *to, const Packet2ui &from)
EIGEN_STRONG_INLINE Packet4f pcmp_eq< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4bf pcmp_le< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE Packet2d padd< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE uint8_t predux< Packet8uc >(const Packet8uc &a)
EIGEN_STRONG_INLINE Packet2d pmax< PropagateNaN, Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc pgather< uint8_t, Packet4uc >(const uint8_t *from, Index stride)
EIGEN_STRONG_INLINE Packet8uc pmin< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE Packet8s pabsdiff< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet16c psub< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_STRONG_INLINE uint64_t pfirst< Packet2ul >(const Packet2ul &a)
EIGEN_STRONG_INLINE Packet4ui pcmp_lt< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE int64_t predux_max< Packet2l >(const Packet2l &a)
EIGEN_STRONG_INLINE Packet4bf pmax< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE Packet2f pmul< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet8uc pand< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE uint8_t predux_mul< Packet8uc >(const Packet8uc &a)
EIGEN_STRONG_INLINE Packet2ui pcmp_le< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet4i ploadquad< Packet4i >(const int32_t *from)
EIGEN_STRONG_INLINE Packet16c pdiv< Packet16c >(const Packet16c &, const Packet16c &)
EIGEN_STRONG_INLINE Packet4f vec4f_swizzle1(const Packet4f &a, int p, int q, int r, int s)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet2i >(Packet2i &p1, Packet2i &p2)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet8c >(Packet8c &p1, Packet8c &p2)
EIGEN_STRONG_INLINE Packet4i pmul< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE Packet4i plogical_shift_left(const Packet4i &a)
EIGEN_STRONG_INLINE Packet8c pcmp_eq< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE uint8_t predux_min< Packet8uc >(const Packet8uc &a)
EIGEN_STRONG_INLINE Packet4s pand< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE Packet16c pmax< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_STRONG_INLINE Packet4f pmin< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet16uc padd< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE Packet8s pand< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet8s pmul< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet4f vec4f_unpacklo(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE void pstore< double >(double *to, const Packet4d &from)
EIGEN_STRONG_INLINE Packet4f pceil< Packet4f >(const Packet4f &a)
EIGEN_STRONG_INLINE Packet8s ploadu< Packet8s >(const short int *from)
EIGEN_STRONG_INLINE bfloat16 pfirst< Packet4bf >(const Packet4bf &from)
EIGEN_STRONG_INLINE Packet2ui pmax< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet4us pand< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_STRONG_INLINE Packet4s pmul< Packet4s >(const Packet4s &a, const Packet4s &b)
__vector unsigned int Packet4ui
EIGEN_STRONG_INLINE Packet2ui ploadu< Packet2ui >(const uint32_t *from)
EIGEN_STRONG_INLINE Packet8us pmin< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_STRONG_INLINE Packet4f pmul< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_DEVICE_FUNC const Scalar & q
EIGEN_STRONG_INLINE Packet8uc pmax< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE Packet8c pcmp_le< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE unsigned char predux< Packet16uc >(const Packet16uc &a)
EIGEN_STRONG_INLINE void prefetch< uint16_t >(const uint16_t *addr)
EIGEN_STRONG_INLINE Packet4uc plset< Packet4uc >(const uint8_t &a)
EIGEN_STRONG_INLINE Packet4us pmul< Packet4us >(const Packet4us &a, const Packet4us &b)
eigen_packet_wrapper< int32_t,2 > Packet4c
EIGEN_STRONG_INLINE Packet16uc plset< Packet16uc >(const unsigned char &a)
EIGEN_STRONG_INLINE Packet2ul pload< Packet2ul >(const uint64_t *from)
EIGEN_STRONG_INLINE bfloat16 predux_min< Packet4bf >(const Packet4bf &a)
EIGEN_STRONG_INLINE Packet16c pandnot< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_STRONG_INLINE Packet4ui plset< Packet4ui >(const uint32_t &a)
EIGEN_STRONG_INLINE Packet2l psub< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_STRONG_INLINE Packet2d pxor< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf &a)
EIGEN_STRONG_INLINE Packet8c pload< Packet8c >(const int8_t *from)
EIGEN_STRONG_INLINE Packet2d plset< Packet2d >(const double &a)
EIGEN_STRONG_INLINE int64_t predux_mul< Packet2l >(const Packet2l &a)
EIGEN_STRONG_INLINE uint16_t predux_max< Packet4us >(const Packet4us &a)
EIGEN_STRONG_INLINE Packet8s pmax< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet8c pxor< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE Packet2f plset< Packet2f >(const float &a)
EIGEN_STRONG_INLINE Packet4f pset1< Packet4f >(const float &from)
EIGEN_STRONG_INLINE void ptranspose(PacketBlock< Packet2cf, 2 > &kernel)
graph add(PriorFactor< Pose2 >(1, priorMean, priorNoise))
EIGEN_STRONG_INLINE Packet4i por< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE uint64_t predux_max< Packet2ul >(const Packet2ul &a)
EIGEN_STRONG_INLINE Packet8bf F32ToBf16(Packet4f p4f)
EIGEN_STRONG_INLINE Packet2i pandnot< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE uint8_t predux_max< Packet4uc >(const Packet4uc &a)
EIGEN_STRONG_INLINE Packet16c pcmp_eq< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int64_t, Packet2l >(int64_t *to, const Packet2l &from, Index stride)
EIGEN_STRONG_INLINE Packet4f pselect(const Packet4f &mask, const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4ui pmul< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE uint16_t predux< Packet4us >(const Packet4us &a)
EIGEN_STRONG_INLINE Packet4us pset1< Packet4us >(const uint16_t &from)
EIGEN_STRONG_INLINE Packet4uc ploadu< Packet4uc >(const uint8_t *from)
EIGEN_STRONG_INLINE Packet8s pandnot< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet4bf pcmp_lt< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE Packet2f pceil< Packet2f >(const Packet2f &a)
EIGEN_STRONG_INLINE Packet4us pxor< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_STRONG_INLINE int predux_min< Packet4i >(const Packet4i &a)
EIGEN_STRONG_INLINE uint8_t predux_mul< Packet4uc >(const Packet4uc &a)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet4us >(Packet4us &p1, Packet4us &p2)
EIGEN_STRONG_INLINE Packet2ul pand< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
#define EIGEN_DEBUG_ALIGNED_LOAD
EIGEN_STRONG_INLINE Packet8uc pset1< Packet8uc >(const uint8_t &from)
#define EIGEN_STRONG_INLINE
#define EIGEN_UNROLL_LOOP
EIGEN_STRONG_INLINE Packet16c pxor< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_STRONG_INLINE Packet2l pload< Packet2l >(const int64_t *from)
EIGEN_STRONG_INLINE Packet2f pcmp_le< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet4f shuffle2< true >(const Packet4f &m, const Packet4f &n, int mask)
EIGEN_STRONG_INLINE Packet4i pdiv< Packet4i >(const Packet4i &, const Packet4i &)
EIGEN_STRONG_INLINE Packet2ui pmin< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet16c pcmp_lt< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_STRONG_INLINE float predux_mul< Packet4f >(const Packet4f &a)
EIGEN_STRONG_INLINE Packet8s por< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int8_t, Packet8c >(int8_t *to, const Packet8c &from, Index stride)
EIGEN_STRONG_INLINE Packet4us por< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_STRONG_INLINE uint32_t pfirst< Packet2ui >(const Packet2ui &a)
EIGEN_STRONG_INLINE Packet4c pmin< Packet4c >(const Packet4c &a, const Packet4c &b)
EIGEN_STRONG_INLINE Packet8c pmax< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE Packet8s padd< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet8c pdiv< Packet8c >(const Packet8c &, const Packet8c &)
EIGEN_STRONG_INLINE Packet4c por< Packet4c >(const Packet4c &a, const Packet4c &b)
#define EIGEN_OPTIMIZATION_BARRIER(X)
EIGEN_STRONG_INLINE void pscatter< bfloat16, Packet4bf >(bfloat16 *to, const Packet4bf &from, Index stride)
EIGEN_STRONG_INLINE Packet4f pmin< PropagateNaN, Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int16_t, Packet8s >(int16_t *to, const Packet8s &from, Index stride)
EIGEN_DEVICE_FUNC void pscatter< double, Packet2d >(double *to, const Packet2d &from, Index stride)
EIGEN_STRONG_INLINE Packet8s pload< Packet8s >(const short int *from)
EIGEN_STRONG_INLINE void pstoreu< int8_t >(int8_t *to, const Packet4c &from)
EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4bf pabsdiff< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE uint32_t predux_max< Packet2ui >(const Packet2ui &a)
EIGEN_STRONG_INLINE int16_t predux_min< Packet4s >(const Packet4s &a)
EIGEN_STRONG_INLINE Packet8us pload< Packet8us >(const unsigned short int *from)
EIGEN_STRONG_INLINE Packet4bf print< Packet4bf >(const Packet4bf &a)
EIGEN_STRONG_INLINE unsigned short int predux_mul< Packet8us >(const Packet8us &a)
EIGEN_STRONG_INLINE Packet8h pand(const Packet8h &a, const Packet8h &b)
EIGEN_DEVICE_FUNC void pscatter< float, Packet4f >(float *to, const Packet4f &from, Index stride)
EIGEN_STRONG_INLINE Packet4s pmax< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE Packet4ui pandnot< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE uint64_t predux_min< Packet2ul >(const Packet2ul &a)
EIGEN_STRONG_INLINE Packet2ui pxor< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet8uc plset< Packet8uc >(const uint8_t &a)
EIGEN_STRONG_INLINE Packet2f pcmp_lt< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet8uc pcmp_le< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_DEVICE_FUNC Packet psub(const Packet &a, const Packet &b)
EIGEN_STRONG_INLINE void pstore< uint64_t >(uint64_t *to, const Packet2ul &from)
EIGEN_STRONG_INLINE Packet8us pcmp_lt< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_STRONG_INLINE Packet4f pmin< PropagateNumbers, Packet4f >(const Packet4f &a, const Packet4f &b)
#define EIGEN_ALWAYS_INLINE
eigen_packet_wrapper< uint32_t,5 > Packet4uc
EIGEN_STRONG_INLINE uint64_t predux_mul< Packet2ul >(const Packet2ul &a)
EIGEN_STRONG_INLINE Packet4c pmul< Packet4c >(const Packet4c &a, const Packet4c &b)
A small structure to hold a non zero as a triplet (i,j,value).
EIGEN_STRONG_INLINE Packet4s pcmp_lt< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE Packet2f pmax< PropagateNaN, Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet4ui pdiv< Packet4ui >(const Packet4ui &, const Packet4ui &)
EIGEN_STRONG_INLINE Packet4s pload< Packet4s >(const int16_t *from)
EIGEN_STRONG_INLINE Packet2f pldexp< Packet2f >(const Packet2f &a, const Packet2f &exponent)
EIGEN_STRONG_INLINE Packet8us ploaddup< Packet8us >(const unsigned short int *from)
EIGEN_STRONG_INLINE Packet8uc ploadu< Packet8uc >(const uint8_t *from)
EIGEN_STRONG_INLINE Packet4f vec4f_movelh(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE uint8_t predux_min< Packet4uc >(const Packet4uc &a)
EIGEN_STRONG_INLINE Packet4bf pceil< Packet4bf >(const Packet4bf &a)
EIGEN_STRONG_INLINE Packet2d pandnot< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet4bf psub< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE float predux_min< Packet4f >(const Packet4f &a)
EIGEN_STRONG_INLINE uint8_t pfirst< Packet8uc >(const Packet8uc &a)
EIGEN_STRONG_INLINE double predux_mul< Packet2d >(const Packet2d &a)
void zip_in_place(Packet &p1, Packet &p2)
EIGEN_STRONG_INLINE Packet8us pdiv< Packet8us >(const Packet8us &, const Packet8us &)
EIGEN_STRONG_INLINE Packet2f psub< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet2ul ploadu< Packet2ul >(const uint64_t *from)
EIGEN_STRONG_INLINE Packet4f vec4f_movehl(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet2ui pdiv< Packet2ui >(const Packet2ui &, const Packet2ui &)
EIGEN_STRONG_INLINE Packet2ul pxor< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet16uc >(Packet16uc &p1, Packet16uc &p2)
EIGEN_STRONG_INLINE Packet8s plset< Packet8s >(const short int &a)
__vector short int Packet8s
EIGEN_STRONG_INLINE Packet4f plset< Packet4f >(const float &a)
EIGEN_STRONG_INLINE int32_t predux_max< Packet2i >(const Packet2i &a)
EIGEN_STRONG_INLINE Packet4c ploadu< Packet4c >(const int8_t *from)
EIGEN_STRONG_INLINE Packet4us plset< Packet4us >(const uint16_t &a)
EIGEN_STRONG_INLINE Packet4uc pmin< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
eigen_packet_wrapper< uint16x4_t, 19 > Packet4bf
EIGEN_STRONG_INLINE Packet8c pand< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE int64_t pfirst< Packet2l >(const Packet2l &a)
EIGEN_STRONG_INLINE Packet4f ploaddup< Packet4f >(const float *from)
EIGEN_STRONG_INLINE Packet2f pxor< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet2l plset< Packet2l >(const int64_t &a)
EIGEN_STRONG_INLINE Packet2f pcmp_eq< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE uint32_t predux_mul< Packet2ui >(const Packet2ui &a)
EIGEN_STRONG_INLINE Packet16uc pload< Packet16uc >(const unsigned char *from)
EIGEN_STRONG_INLINE void pstoreu< uint32_t >(uint32_t *to, const Packet2ui &from)
EIGEN_STRONG_INLINE Packet2f pcmp_lt_or_nan< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet16c pabsdiff< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< float, Packet2f >(float *to, const Packet2f &from, Index stride)
EIGEN_STRONG_INLINE Packet2ul pdiv< Packet2ul >(const Packet2ul &, const Packet2ul &)
EIGEN_STRONG_INLINE Packet4ui psub< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE Packet2d psub< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE bool predux_any(const Packet4f &x)
Point2(* f)(const Point3 &, OptionalJacobian< 2, 3 >)
EIGEN_STRONG_INLINE uint32_t predux< Packet4ui >(const Packet4ui &a)
EIGEN_STRONG_INLINE Packet2f pmax< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE unsigned short int pfirst< Packet8us >(const Packet8us &a)
EIGEN_STRONG_INLINE Packet8f pzero(const Packet8f &)
EIGEN_STRONG_INLINE Packet4s ploaddup< Packet4s >(const int16_t *from)
EIGEN_STRONG_INLINE Packet2l pmax< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet4ui >(Packet4ui &p1, Packet4ui &p2)
EIGEN_STRONG_INLINE void pstoreu< bfloat16 >(bfloat16 *to, const Packet8bf &from)
EIGEN_STRONG_INLINE Packet4bf pcmp_lt_or_nan< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE Packet4f pabs< Packet4f >(const Packet4f &a)
EIGEN_STRONG_INLINE Packet16uc pcmp_eq< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE int32_t pfirst< Packet2i >(const Packet2i &a)
EIGEN_STRONG_INLINE Packet8f Bf16ToF32(const Packet8bf &a)
EIGEN_STRONG_INLINE int predux< Packet4i >(const Packet4i &a)
EIGEN_STRONG_INLINE Packet4bf plset< Packet4bf >(const bfloat16 &a)
EIGEN_STRONG_INLINE void pstoreu< int64_t >(int64_t *to, const Packet2l &from)
EIGEN_STRONG_INLINE Packet2f pload< Packet2f >(const float *from)
EIGEN_STRONG_INLINE Packet2ui ploaddup< Packet2ui >(const uint32_t *from)
EIGEN_STRONG_INLINE unsigned short int predux_max< Packet8us >(const Packet8us &a)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c pgather< int8_t, Packet16c >(const int8_t *from, Index stride)
EIGEN_STRONG_INLINE Packet4s por< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE uint32_t predux< Packet2ui >(const Packet2ui &a)
EIGEN_STRONG_INLINE void pstore< int8_t >(int8_t *to, const Packet4c &from)
EIGEN_STRONG_INLINE Packet4i pcmp_eq< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE Packet4bf preverse< Packet4bf >(const Packet4bf &a)
EIGEN_STRONG_INLINE Packet2i pand< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE Packet2ul pandnot< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
EIGEN_STRONG_INLINE Packet16uc psub< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_DEVICE_FUNC Packet pmul(const Packet &a, const Packet &b)
EIGEN_STRONG_INLINE void pstoreu< uint64_t >(uint64_t *to, const Packet2ul &from)
EIGEN_STRONG_INLINE Packet2d pceil< Packet2d >(const Packet2d &a)
EIGEN_STRONG_INLINE float predux< Packet2f >(const Packet2f &a)
EIGEN_STRONG_INLINE void pstore< int32_t >(int32_t *to, const Packet4i &from)
EIGEN_STRONG_INLINE void pstoreu< int32_t >(int32_t *to, const Packet4i &from)
EIGEN_STRONG_INLINE Packet2i pcmp_lt< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE bfloat16 predux< Packet4bf >(const Packet4bf &a)
EIGEN_STRONG_INLINE Packet8us pcmp_le< Packet8us >(const Packet8us &a, const Packet8us &b)
EIGEN_STRONG_INLINE Packet4s pdiv< Packet4s >(const Packet4s &, const Packet4s &)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet4f >(Packet4f &p1, Packet4f &p2)
#define EIGEN_DEBUG_UNALIGNED_LOAD
EIGEN_STRONG_INLINE uint64_t predux< Packet2ul >(const Packet2ul &a)
EIGEN_STRONG_INLINE void pstore< int16_t >(int16_t *to, const Packet4s &from)
EIGEN_STRONG_INLINE Packet8uc psub< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE Packet16uc pcmp_lt< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE uint32_t predux_max< Packet4ui >(const Packet4ui &a)
EIGEN_STRONG_INLINE Packet2f pset1< Packet2f >(const float &from)
EIGEN_STRONG_INLINE Packet2d pmax< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE float pfirst< Packet2f >(const Packet2f &a)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint32_t, Packet2ui >(uint32_t *to, const Packet2ui &from, Index stride)
EIGEN_STRONG_INLINE double pfirst< Packet2d >(const Packet2d &a)
EIGEN_STRONG_INLINE Packet4ui pcmp_eq< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE int64_t predux_min< Packet2l >(const Packet2l &a)
EIGEN_STRONG_INLINE int8_t pfirst< Packet4c >(const Packet4c &a)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc pgather< uint8_t, Packet16uc >(const uint8_t *from, Index stride)
EIGEN_STRONG_INLINE Packet8uc ploadquad< Packet8uc >(const uint8_t *from)
EIGEN_STRONG_INLINE Packet2i padd< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE Packet2i pcmp_le< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE Packet4f pmax< PropagateNaN, Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4f por< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4uc pcmp_eq< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_STRONG_INLINE Packet4i plogical_shift_right(const Packet4i &a)
EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f &a, const Packet4f &b, const Packet4f &c)
EIGEN_STRONG_INLINE Packet4ui ploaddup< Packet4ui >(const uint32_t *from)
EIGEN_STRONG_INLINE Packet2l pcmp_eq< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_STRONG_INLINE Packet4f pand< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet8c pmin< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE Packet4c psub< Packet4c >(const Packet4c &a, const Packet4c &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s pgather< int16_t, Packet8s >(const int16_t *from, Index stride)
EIGEN_STRONG_INLINE Packet4bf pdiv< Packet4bf >(const Packet4bf &a, const Packet4bf &b)
EIGEN_STRONG_INLINE void prefetch< int64_t >(const int64_t *addr)
EIGEN_STRONG_INLINE Packet2ul ploaddup< Packet2ul >(const uint64_t *from)
EIGEN_STRONG_INLINE Packet2d pmin< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet2ul pcmp_le< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
EIGEN_STRONG_INLINE Packet2ul pmax< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
EIGEN_STRONG_INLINE void pstoreu< double >(double *to, const Packet4d &from)
EIGEN_STRONG_INLINE Packet4bf pload< Packet4bf >(const bfloat16 *from)
EIGEN_STRONG_INLINE Packet8s pset1< Packet8s >(const short int &from)
EIGEN_STRONG_INLINE Packet4ui ploadquad< Packet4ui >(const uint32_t *from)
EIGEN_STRONG_INLINE Packet4c pandnot< Packet4c >(const Packet4c &a, const Packet4c &b)
EIGEN_STRONG_INLINE float predux_min< Packet2f >(const Packet2f &a)
EIGEN_STRONG_INLINE Packet4us pmax< Packet4us >(const Packet4us &a, const Packet4us &b)
EIGEN_STRONG_INLINE float predux< Packet4f >(const Packet4f &a)
EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f &a)
EIGEN_STRONG_INLINE Packet2ui psub< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet8s pxor< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE uint8_t predux< Packet4uc >(const Packet4uc &a)
EIGEN_STRONG_INLINE Packet2ui pcmp_lt< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet16uc ploaddup< Packet16uc >(const unsigned char *from)
EIGEN_DEVICE_FUNC Packet padd(const Packet &a, const Packet &b)
#define vec2d_swizzle2(a, b, mask)
EIGEN_STRONG_INLINE Packet4uc pcmp_le< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_STRONG_INLINE float predux_max< Packet2f >(const Packet2f &a)
EIGEN_STRONG_INLINE void prefetch< int8_t >(const int8_t *addr)
EIGEN_STRONG_INLINE unsigned short int predux_min< Packet8us >(const Packet8us &a)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet4i >(Packet4i &p1, Packet4i &p2)
EIGEN_STRONG_INLINE Packet16c ploadu< Packet16c >(const signed char *from)
EIGEN_STRONG_INLINE Packet8c padd< Packet8c >(const Packet8c &a, const Packet8c &b)
__vector signed char Packet16c
EIGEN_STRONG_INLINE Packet2i pmax< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE int8_t predux_max< Packet8c >(const Packet8c &a)
EIGEN_STRONG_INLINE Packet4us ploadu< Packet4us >(const uint16_t *from)
EIGEN_DEVICE_FUNC Packet4i pgather< int32_t, Packet4i >(const int32_t *from, Index stride)
EIGEN_STRONG_INLINE Packet2f ploadu< Packet2f >(const float *from)
EIGEN_STRONG_INLINE Packet2i psub< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE bfloat16 predux_mul< Packet4bf >(const Packet4bf &a)
EIGEN_STRONG_INLINE Packet4c pxor< Packet4c >(const Packet4c &a, const Packet4c &b)
EIGEN_STRONG_INLINE Packet16uc pandnot< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE short int pfirst< Packet8s >(const Packet8s &a)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet4s >(Packet4s &p1, Packet4s &p2)
EIGEN_STRONG_INLINE float pfirst< Packet4f >(const Packet4f &a)
EIGEN_STRONG_INLINE Packet8h por(const Packet8h &a, const Packet8h &b)
EIGEN_STRONG_INLINE Packet4s padd< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE uint16_t predux_mul< Packet4us >(const Packet4us &a)
EIGEN_STRONG_INLINE Packet16c pmin< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_STRONG_INLINE Packet2d pmax< PropagateNumbers, Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet8s ploaddup< Packet8s >(const short int *from)
EIGEN_STRONG_INLINE void prefetch< uint64_t >(const uint64_t *addr)
EIGEN_STRONG_INLINE Packet8us pset1< Packet8us >(const unsigned short int &from)
EIGEN_STRONG_INLINE Packet2d pfloor< Packet2d >(const Packet2d &a)
EIGEN_STRONG_INLINE Packet8s pmin< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet4uc psub< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_STRONG_INLINE Packet4uc pandnot< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_STRONG_INLINE Packet4f pxor< Packet4f >(const Packet4f &a, const Packet4f &b)
unsigned __int64 uint64_t
EIGEN_STRONG_INLINE Packet8uc pdiv< Packet8uc >(const Packet8uc &, const Packet8uc &)
EIGEN_STRONG_INLINE Packet2f pand< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet2l ploaddup< Packet2l >(const int64_t *from)
EIGEN_STRONG_INLINE Packet4uc pmul< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_STRONG_INLINE Packet4uc pmax< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
CleanedUpDerType< DerType >::type() min(const AutoDiffScalar< DerType > &x, const T &y)
EIGEN_STRONG_INLINE void pstoreu< float >(float *to, const Packet4f &from)
EIGEN_STRONG_INLINE Packet4f print< Packet4f >(const Packet4f &a)
EIGEN_STRONG_INLINE short int predux_mul< Packet8s >(const Packet8s &a)
EIGEN_STRONG_INLINE Packet16c pcmp_le< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_STRONG_INLINE Packet4c pabs< Packet4c >(const Packet4c &a)
EIGEN_STRONG_INLINE Packet4f vec4f_swizzle2(const Packet4f &a, const Packet4f &b, int p, int q, int r, int s)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint8_t, Packet16uc >(uint8_t *to, const Packet16uc &from, Index stride)
EIGEN_STRONG_INLINE int predux_mul< Packet4i >(const Packet4i &a)
EIGEN_STRONG_INLINE Packet4f prsqrt(const Packet4f &a)
EIGEN_STRONG_INLINE Packet8us plset< Packet8us >(const unsigned short int &a)
EIGEN_STRONG_INLINE double predux< Packet2d >(const Packet2d &a)
EIGEN_STRONG_INLINE Packet4f pabsdiff< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE double predux_min< Packet2d >(const Packet2d &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet pldexp_generic(const Packet &a, const Packet &exponent)
EIGEN_STRONG_INLINE Packet16uc pmul< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE Packet4i pabsdiff< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE Packet2ul pset1< Packet2ul >(const uint64_t &from)
EIGEN_STRONG_INLINE Packet4f pdiv< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet2i pmul< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE Packet4s pandnot< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE int8_t predux< Packet4c >(const Packet4c &a)
EIGEN_STRONG_INLINE Packet4c ploaddup< Packet4c >(const int8_t *from)
static EIGEN_STRONG_INLINE int eigen_neon_shuffle_mask(int p, int q, int r, int s)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c pgather< int8_t, Packet8c >(const int8_t *from, Index stride)
EIGEN_STRONG_INLINE short int predux< Packet8s >(const Packet8s &a)
EIGEN_STRONG_INLINE int16_t predux_max< Packet4s >(const Packet4s &a)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c pgather< int8_t, Packet4c >(const int8_t *from, Index stride)
EIGEN_STRONG_INLINE Packet4i pmax< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE Packet2l pmul< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_STRONG_INLINE Packet8h pandnot(const Packet8h &a, const Packet8h &b)
EIGEN_STRONG_INLINE void prefetch< uint8_t >(const uint8_t *addr)
EIGEN_STRONG_INLINE Packet4bf pfloor< Packet4bf >(const Packet4bf &a)
EIGEN_STRONG_INLINE Packet4c pand< Packet4c >(const Packet4c &a, const Packet4c &b)
EIGEN_STRONG_INLINE Packet4uc pdiv< Packet4uc >(const Packet4uc &, const Packet4uc &)
EIGEN_STRONG_INLINE signed char predux_min< Packet16c >(const Packet16c &a)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l pgather< int64_t, Packet2l >(const int64_t *from, Index stride)
EIGEN_STRONG_INLINE Packet2l ploadu< Packet2l >(const int64_t *from)
EIGEN_STRONG_INLINE Packet4c pset1< Packet4c >(const int8_t &from)
EIGEN_STRONG_INLINE signed char pfirst< Packet16c >(const Packet16c &a)
EIGEN_STRONG_INLINE unsigned char predux_mul< Packet16uc >(const Packet16uc &a)
EIGEN_STRONG_INLINE Packet4i pcmp_lt< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us pgather< uint16_t, Packet4us >(const uint16_t *from, Index stride)
EIGEN_ALWAYS_INLINE void zip_in_place< Packet2ui >(Packet2ui &p1, Packet2ui &p2)
EIGEN_STRONG_INLINE Packet4f pmax< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet2f pfrexp< Packet2f >(const Packet2f &a, Packet2f &exponent)
EIGEN_STRONG_INLINE Packet8uc padd< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE Packet8uc por< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE Packet16c por< Packet16c >(const Packet16c &a, const Packet16c &b)
EIGEN_ALWAYS_INLINE void ptranspose_impl(PacketBlock< Packet, 2 > &kernel)
EIGEN_STRONG_INLINE Packet4i pmin< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE Packet2d paddsub< Packet2d >(const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet4c padd< Packet4c >(const Packet4c &a, const Packet4c &b)
EIGEN_STRONG_INLINE Packet4c pcmp_lt< Packet4c >(const Packet4c &a, const Packet4c &b)
EIGEN_STRONG_INLINE Packet2ui padd< Packet2ui >(const Packet2ui &a, const Packet2ui &b)
EIGEN_STRONG_INLINE Packet2l pmin< Packet2l >(const Packet2l &a, const Packet2l &b)
EIGEN_STRONG_INLINE Packet4bf pset1< Packet4bf >(const bfloat16 &from)
EIGEN_STRONG_INLINE void prefetch< double >(const double *addr)
EIGEN_STRONG_INLINE int16_t pfirst< Packet4s >(const Packet4s &a)
EIGEN_STRONG_INLINE Packet4uc pand< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_STRONG_INLINE Packet4ui pxor< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE Packet4f pcmp_le(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet8c pset1< Packet8c >(const int8_t &from)
EIGEN_STRONG_INLINE Packet4i pset1< Packet4i >(const int &from)
EIGEN_STRONG_INLINE Packet8c pcmp_lt< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE Packet2l pcmp_lt< Packet2l >(const Packet2l &a, const Packet2l &b)
const Product< Lhs, Rhs > prod(const Lhs &lhs, const Rhs &rhs)
EIGEN_STRONG_INLINE Packet4ui pmax< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE short int predux_max< Packet8s >(const Packet8s &a)
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
EIGEN_STRONG_INLINE Packet4ui pload< Packet4ui >(const uint32_t *from)
EIGEN_STRONG_INLINE Packet8uc pmul< Packet8uc >(const Packet8uc &a, const Packet8uc &b)
EIGEN_STRONG_INLINE Packet8c pabsdiff< Packet8c >(const Packet8c &a, const Packet8c &b)
EIGEN_STRONG_INLINE Packet4ui pabsdiff< Packet4ui >(const Packet4ui &a, const Packet4ui &b)
EIGEN_STRONG_INLINE Packet16c pset1< Packet16c >(const signed char &from)
EIGEN_STRONG_INLINE Packet2i pabsdiff< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int32_t, Packet2i >(int32_t *to, const Packet2i &from, Index stride)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f pgather< float, Packet2f >(const float *from, Index stride)
EIGEN_STRONG_INLINE int predux_max< Packet4i >(const Packet4i &a)
EIGEN_STRONG_INLINE Packet2f pdiv< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet2d pload< Packet2d >(const double *from)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui pgather< uint32_t, Packet2ui >(const uint32_t *from, Index stride)
EIGEN_STRONG_INLINE Packet8us psub< Packet8us >(const Packet8us &a, const Packet8us &b)
#define EIGEN_DEBUG_ALIGNED_STORE
EIGEN_STRONG_INLINE Packet2f pmin< Packet2f >(const Packet2f &a, const Packet2f &b)
EIGEN_STRONG_INLINE Packet8s pdiv< Packet8s >(const Packet8s &, const Packet8s &)
EIGEN_STRONG_INLINE void pstore< float >(float *to, const Packet4f &from)
EIGEN_STRONG_INLINE Packet16uc pcmp_le< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
__vector unsigned short int Packet8us
EIGEN_STRONG_INLINE Packet4uc pxor< Packet4uc >(const Packet4uc &a, const Packet4uc &b)
EIGEN_STRONG_INLINE Packet2i pset1< Packet2i >(const int32_t &from)
EIGEN_STRONG_INLINE Packet2l pdiv< Packet2l >(const Packet2l &, const Packet2l &)
EIGEN_STRONG_INLINE Packet2f pfloor< Packet2f >(const Packet2f &a)
EIGEN_STRONG_INLINE int32_t predux_min< Packet2i >(const Packet2i &a)
EIGEN_STRONG_INLINE Packet4i padd< Packet4i >(const Packet4i &a, const Packet4i &b)
EIGEN_STRONG_INLINE Packet2ui pload< Packet2ui >(const uint32_t *from)
EIGEN_STRONG_INLINE Packet8s psub< Packet8s >(const Packet8s &a, const Packet8s &b)
EIGEN_STRONG_INLINE Packet16c pload< Packet16c >(const signed char *from)
EIGEN_STRONG_INLINE Packet16uc pmin< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE Packet2d vec2d_unpacklo(const Packet2d &a, const Packet2d &b)
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
EIGEN_STRONG_INLINE Packet4i ploaddup< Packet4i >(const int *from)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int8_t, Packet4c >(int8_t *to, const Packet4c &from, Index stride)
EIGEN_STRONG_INLINE uint32_t predux_min< Packet2ui >(const Packet2ui &a)
EIGEN_STRONG_INLINE Packet4s pxor< Packet4s >(const Packet4s &a, const Packet4s &b)
EIGEN_STRONG_INLINE void pstoreu< uint8_t >(uint8_t *to, const Packet4uc &from)
EIGEN_STRONG_INLINE Packet2i pcmp_eq< Packet2i >(const Packet2i &a, const Packet2i &b)
EIGEN_STRONG_INLINE Packet16uc ploadu< Packet16uc >(const unsigned char *from)
EIGEN_STRONG_INLINE Packet16uc pdiv< Packet16uc >(const Packet16uc &, const Packet16uc &)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet pfrexp_generic(const Packet &a, Packet &exponent)
EIGEN_STRONG_INLINE Packet16uc pand< Packet16uc >(const Packet16uc &a, const Packet16uc &b)
EIGEN_STRONG_INLINE Packet2ul padd< Packet2ul >(const Packet2ul &a, const Packet2ul &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int16_t, Packet4s >(int16_t *to, const Packet4s &from, Index stride)
EIGEN_STRONG_INLINE int8_t pfirst< Packet8c >(const Packet8c &a)
gtsam
Author(s):
autogenerated on Fri Nov 1 2024 03:33:53