12#ifndef EIGEN_PACKET2_MATH_RVV10_H
13#define EIGEN_PACKET2_MATH_RVV10_H
16#include "../../InternalHeaderCheck.h"
23EIGEN_STRONG_INLINE Packet2Xi __riscv_vreinterpret_v_u64m2_i32m2(
const Packet2Xul& a) {
24 return __riscv_vreinterpret_v_i64m2_i32m2(__riscv_vreinterpret_v_u64m2_i64m2(a));
28EIGEN_STRONG_INLINE Packet2Xi pset1<Packet2Xi>(
const numext::int32_t& from) {
29 return __riscv_vmv_v_x_i32m2(from, unpacket_traits<Packet2Xi>::size);
33EIGEN_STRONG_INLINE Packet2Xi plset<Packet2Xi>(
const numext::int32_t& a) {
34 Packet2Xi idx = __riscv_vreinterpret_v_u32m2_i32m2(__riscv_vid_v_u32m2(unpacket_traits<Packet2Xi>::size));
35 return __riscv_vadd_vx_i32m2(idx, a, unpacket_traits<Packet2Xi>::size);
39EIGEN_STRONG_INLINE Packet2Xi pzero<Packet2Xi>(
const Packet2Xi& ) {
40 return __riscv_vmv_v_x_i32m2(0, unpacket_traits<Packet2Xi>::size);
44EIGEN_STRONG_INLINE Packet2Xi padd<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
45 return __riscv_vadd_vv_i32m2(a, b, unpacket_traits<Packet2Xi>::size);
49EIGEN_STRONG_INLINE Packet2Xi psub<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
50 return __riscv_vsub(a, b, unpacket_traits<Packet2Xi>::size);
54EIGEN_STRONG_INLINE Packet2Xi pnegate(
const Packet2Xi& a) {
55 return __riscv_vneg(a, unpacket_traits<Packet2Xi>::size);
59EIGEN_STRONG_INLINE Packet2Xi pmul<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
60 return __riscv_vmul(a, b, unpacket_traits<Packet2Xi>::size);
64EIGEN_STRONG_INLINE Packet2Xi pdiv<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
65 return __riscv_vdiv(a, b, unpacket_traits<Packet2Xi>::size);
69EIGEN_STRONG_INLINE Packet2Xi pmadd(
const Packet2Xi& a,
const Packet2Xi& b,
const Packet2Xi& c) {
70 return __riscv_vmadd(a, b, c, unpacket_traits<Packet2Xi>::size);
74EIGEN_STRONG_INLINE Packet2Xi pmsub(
const Packet2Xi& a,
const Packet2Xi& b,
const Packet2Xi& c) {
75 return __riscv_vmadd(a, b, pnegate(c), unpacket_traits<Packet2Xi>::size);
79EIGEN_STRONG_INLINE Packet2Xi pnmadd(
const Packet2Xi& a,
const Packet2Xi& b,
const Packet2Xi& c) {
80 return __riscv_vnmsub_vv_i32m2(a, b, c, unpacket_traits<Packet2Xi>::size);
84EIGEN_STRONG_INLINE Packet2Xi pnmsub(
const Packet2Xi& a,
const Packet2Xi& b,
const Packet2Xi& c) {
85 return __riscv_vnmsub_vv_i32m2(a, b, pnegate(c), unpacket_traits<Packet2Xi>::size);
89EIGEN_STRONG_INLINE Packet2Xi pmin<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
90 return __riscv_vmin(a, b, unpacket_traits<Packet2Xi>::size);
94EIGEN_STRONG_INLINE Packet2Xi pmax<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
95 return __riscv_vmax(a, b, unpacket_traits<Packet2Xi>::size);
99EIGEN_STRONG_INLINE Packet2Xi pcmp_le<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
100 PacketMask16 mask = __riscv_vmsle_vv_i32m2_b16(a, b, unpacket_traits<Packet2Xi>::size);
101 return __riscv_vmerge_vxm_i32m2(pzero(a), 0xffffffff, mask, unpacket_traits<Packet2Xi>::size);
105EIGEN_STRONG_INLINE Packet2Xi pcmp_lt<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
106 PacketMask16 mask = __riscv_vmslt_vv_i32m2_b16(a, b, unpacket_traits<Packet2Xi>::size);
107 return __riscv_vmerge_vxm_i32m2(pzero(a), 0xffffffff, mask, unpacket_traits<Packet2Xi>::size);
111EIGEN_STRONG_INLINE Packet2Xi pcmp_eq<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
112 PacketMask16 mask = __riscv_vmseq_vv_i32m2_b16(a, b, unpacket_traits<Packet2Xi>::size);
113 return __riscv_vmerge_vxm_i32m2(pzero(a), 0xffffffff, mask, unpacket_traits<Packet2Xi>::size);
117EIGEN_STRONG_INLINE Packet2Xi ptrue<Packet2Xi>(
const Packet2Xi& ) {
118 return __riscv_vmv_v_x_i32m2(0xffffffffu, unpacket_traits<Packet2Xi>::size);
122EIGEN_STRONG_INLINE Packet2Xi pand<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
123 return __riscv_vand_vv_i32m2(a, b, unpacket_traits<Packet2Xi>::size);
127EIGEN_STRONG_INLINE Packet2Xi por<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
128 return __riscv_vor_vv_i32m2(a, b, unpacket_traits<Packet2Xi>::size);
132EIGEN_STRONG_INLINE Packet2Xi pxor<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
133 return __riscv_vxor_vv_i32m2(a, b, unpacket_traits<Packet2Xi>::size);
137EIGEN_STRONG_INLINE Packet2Xi pandnot<Packet2Xi>(
const Packet2Xi& a,
const Packet2Xi& b) {
139 return __riscv_vand_vv_i32m2(a, __riscv_vnot_v_i32m2(b, unpacket_traits<Packet2Xi>::size),
140 unpacket_traits<Packet2Xi>::size);
142 return __riscv_vreinterpret_v_u32m2_i32m2(__riscv_vandn_vv_u32m2(
143 __riscv_vreinterpret_v_i32m2_u32m2(a), __riscv_vreinterpret_v_i32m2_u32m2(b), unpacket_traits<Packet2Xi>::size));
148EIGEN_STRONG_INLINE Packet2Xi pnot<Packet2Xi>(
const Packet2Xi& a) {
149 return __riscv_vnot_v_i32m2(a, unpacket_traits<Packet2Xi>::size);
153EIGEN_STRONG_INLINE Packet2Xi parithmetic_shift_right(
const Packet2Xi& a) {
154 return __riscv_vsra_vx_i32m2(a, N, unpacket_traits<Packet2Xi>::size);
158EIGEN_STRONG_INLINE Packet2Xi plogical_shift_right(
const Packet2Xi& a) {
159 return __riscv_vreinterpret_i32m2(
160 __riscv_vsrl_vx_u32m2(__riscv_vreinterpret_u32m2(a), N, unpacket_traits<Packet2Xi>::size));
164EIGEN_STRONG_INLINE Packet2Xi plogical_shift_left(
const Packet2Xi& a) {
165 return __riscv_vsll_vx_i32m2(a, N, unpacket_traits<Packet2Xi>::size);
169EIGEN_STRONG_INLINE Packet2Xi pload<Packet2Xi>(
const numext::int32_t* from) {
170 EIGEN_DEBUG_ALIGNED_LOAD
return __riscv_vle32_v_i32m2(from, unpacket_traits<Packet2Xi>::size);
174EIGEN_STRONG_INLINE Packet2Xi ploadu<Packet2Xi>(
const numext::int32_t* from) {
175 EIGEN_DEBUG_UNALIGNED_LOAD
return __riscv_vle32_v_i32m2(from, unpacket_traits<Packet2Xi>::size);
179EIGEN_STRONG_INLINE Packet2Xi ploaddup<Packet2Xi>(
const numext::int32_t* from) {
180 Packet2Xul data = __riscv_vlmul_trunc_v_u64m4_u64m2(__riscv_vwcvtu_x_x_v_u64m4(
181 __riscv_vreinterpret_v_i32m2_u32m2(__riscv_vle32_v_i32m2(from, unpacket_traits<Packet2Xi>::size / 2)),
182 unpacket_traits<Packet2Xi>::size / 2));
183 return __riscv_vreinterpret_v_u64m2_i32m2(__riscv_vadd_vv_u64m2(
184 __riscv_vsll_vx_u64m2(data, 32, unpacket_traits<Packet2Xl>::size), data, unpacket_traits<Packet2Xl>::size));
188EIGEN_STRONG_INLINE Packet2Xi ploadquad<Packet2Xi>(
const numext::int32_t* from) {
190 __riscv_vsrl_vx_u32m2(__riscv_vid_v_u32m2(unpacket_traits<Packet2Xi>::size), 2, unpacket_traits<Packet2Xi>::size);
191 return __riscv_vrgather_vv_i32m2(pload<Packet2Xi>(from), idx, unpacket_traits<Packet2Xi>::size);
195EIGEN_STRONG_INLINE
void pstore<numext::int32_t>(numext::int32_t* to,
const Packet2Xi& from) {
196 EIGEN_DEBUG_ALIGNED_STORE __riscv_vse32_v_i32m2(to, from, unpacket_traits<Packet2Xi>::size);
200EIGEN_STRONG_INLINE
void pstoreu<numext::int32_t>(numext::int32_t* to,
const Packet2Xi& from) {
201 EIGEN_DEBUG_UNALIGNED_STORE __riscv_vse32_v_i32m2(to, from, unpacket_traits<Packet2Xi>::size);
205EIGEN_DEVICE_FUNC
inline Packet2Xi pgather<numext::int32_t, Packet2Xi>(
const numext::int32_t* from, Index stride) {
206 return __riscv_vlse32_v_i32m2(from, stride *
sizeof(numext::int32_t), unpacket_traits<Packet2Xi>::size);
210EIGEN_DEVICE_FUNC
inline void pscatter<numext::int32_t, Packet2Xi>(numext::int32_t* to,
const Packet2Xi& from,
212 __riscv_vsse32(to, stride *
sizeof(numext::int32_t), from, unpacket_traits<Packet2Xi>::size);
216EIGEN_STRONG_INLINE numext::int32_t pfirst<Packet2Xi>(
const Packet2Xi& a) {
217 return __riscv_vmv_x_s_i32m2_i32(a);
221EIGEN_STRONG_INLINE Packet2Xi preverse(
const Packet2Xi& a) {
222 Packet2Xu idx = __riscv_vrsub_vx_u32m2(__riscv_vid_v_u32m2(unpacket_traits<Packet2Xi>::size),
223 unpacket_traits<Packet2Xi>::size - 1, unpacket_traits<Packet2Xi>::size);
224 return __riscv_vrgather_vv_i32m2(a, idx, unpacket_traits<Packet2Xi>::size);
228EIGEN_STRONG_INLINE Packet2Xi pabs(
const Packet2Xi& a) {
229 Packet2Xi mask = __riscv_vsra_vx_i32m2(a, 31, unpacket_traits<Packet2Xi>::size);
230 return __riscv_vsub_vv_i32m2(__riscv_vxor_vv_i32m2(a, mask, unpacket_traits<Packet2Xi>::size), mask,
231 unpacket_traits<Packet2Xi>::size);
235EIGEN_STRONG_INLINE numext::int32_t predux<Packet2Xi>(
const Packet2Xi& a) {
236 return __riscv_vmv_x(__riscv_vredsum_vs_i32m2_i32m1(a, __riscv_vmv_v_x_i32m1(0, unpacket_traits<Packet2Xi>::size / 2),
237 unpacket_traits<Packet2Xi>::size));
241EIGEN_STRONG_INLINE
bool predux_all(
const Packet2Xi& a) {
242 const PacketMask16 mask = __riscv_vmseq_vx_i32m2_b16(a, 0, unpacket_traits<Packet2Xi>::size);
243 return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet2Xi>::size) == 0;
247EIGEN_STRONG_INLINE numext::int32_t predux_mul<Packet2Xi>(
const Packet2Xi& a) {
248 return predux_mul<Packet1Xi>(__riscv_vmul_vv_i32m1(__riscv_vget_v_i32m2_i32m1(a, 0), __riscv_vget_v_i32m2_i32m1(a, 1),
249 unpacket_traits<Packet1Xi>::size));
253EIGEN_STRONG_INLINE numext::int32_t predux_min<Packet2Xi>(
const Packet2Xi& a) {
254 return __riscv_vmv_x(__riscv_vredmin_vs_i32m2_i32m1(
255 a, __riscv_vmv_v_x_i32m1((std::numeric_limits<numext::int32_t>::max)(), unpacket_traits<Packet2Xi>::size / 2),
256 unpacket_traits<Packet2Xi>::size));
260EIGEN_STRONG_INLINE numext::int32_t predux_max<Packet2Xi>(
const Packet2Xi& a) {
261 return __riscv_vmv_x(__riscv_vredmax_vs_i32m2_i32m1(
262 a, __riscv_vmv_v_x_i32m1((std::numeric_limits<numext::int32_t>::min)(), unpacket_traits<Packet2Xi>::size / 2),
263 unpacket_traits<Packet2Xi>::size));
267EIGEN_DEVICE_FUNC
inline void ptranspose(PacketBlock<Packet2Xi, N>& kernel) {
268 numext::int32_t buffer[unpacket_traits<Packet2Xi>::size * N] = {0};
271 for (i = 0; i < N; i++) {
272 __riscv_vsse32(&buffer[i], N *
sizeof(numext::int32_t), kernel.packet[i], unpacket_traits<Packet2Xi>::size);
274 for (i = 0; i < N; i++) {
276 __riscv_vle32_v_i32m2(&buffer[i * unpacket_traits<Packet2Xi>::size], unpacket_traits<Packet2Xi>::size);
280template <
typename Packet = Packet2Xi>
282 std::enable_if_t<std::is_same<Packet, Packet2Xi>::value && (unpacket_traits<Packet2Xi>::size % 8) == 0, Packet1Xi>
283 predux_half(
const Packet2Xi& a) {
284 return __riscv_vadd_vv_i32m1(__riscv_vget_v_i32m2_i32m1(a, 0), __riscv_vget_v_i32m2_i32m1(a, 1),
285 unpacket_traits<Packet1Xi>::size);
290EIGEN_STRONG_INLINE Packet4Xf __riscv_vreinterpret_v_u64m4_f32m4(
const Packet4Xul& a) {
291 return __riscv_vreinterpret_v_u32m4_f32m4(__riscv_vreinterpret_v_u64m4_u32m4(a));
295EIGEN_STRONG_INLINE Packet2Xf ptrue<Packet2Xf>(
const Packet2Xf& ) {
296 Packet2Xf r = __riscv_vreinterpret_f32m2(__riscv_vmv_v_x_u32m2(0xffffffffu, unpacket_traits<Packet2Xf>::size));
297 EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
302EIGEN_STRONG_INLINE Packet2Xf pzero<Packet2Xf>(
const Packet2Xf& ) {
303 return __riscv_vfmv_v_f_f32m2(0.0f, unpacket_traits<Packet2Xf>::size);
307EIGEN_STRONG_INLINE Packet2Xf pabs(
const Packet2Xf& a) {
308 return __riscv_vfabs_v_f32m2(a, unpacket_traits<Packet2Xf>::size);
312EIGEN_STRONG_INLINE Packet2Xf pabsdiff(
const Packet2Xf& a,
const Packet2Xf& b) {
313 return __riscv_vfabs_v_f32m2(__riscv_vfsub_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size),
314 unpacket_traits<Packet2Xf>::size);
318EIGEN_STRONG_INLINE Packet2Xf pset1<Packet2Xf>(
const float& from) {
319 return __riscv_vfmv_v_f_f32m2(from, unpacket_traits<Packet2Xf>::size);
323EIGEN_STRONG_INLINE Packet2Xf pset1frombits<Packet2Xf>(numext::uint32_t from) {
324 return __riscv_vreinterpret_f32m2(__riscv_vmv_v_x_u32m2(from, unpacket_traits<Packet2Xf>::size));
328EIGEN_STRONG_INLINE Packet2Xf plset<Packet2Xf>(
const float& a) {
329 Packet2Xf idx = __riscv_vfcvt_f_x_v_f32m2(
330 __riscv_vreinterpret_v_u32m2_i32m2(__riscv_vid_v_u32m2(unpacket_traits<Packet4Xi>::size)),
331 unpacket_traits<Packet2Xf>::size);
332 return __riscv_vfadd_vf_f32m2(idx, a, unpacket_traits<Packet2Xf>::size);
336EIGEN_STRONG_INLINE
void pbroadcast4<Packet2Xf>(
const float* a, Packet2Xf& a0, Packet2Xf& a1, Packet2Xf& a2,
338 Packet2Xf aa = __riscv_vlmul_ext_f32m2(__riscv_vle32_v_f32m1(a, 4));
339 a0 = __riscv_vrgather_vx_f32m2(aa, 0, unpacket_traits<Packet2Xf>::size);
340 a1 = __riscv_vrgather_vx_f32m2(aa, 1, unpacket_traits<Packet2Xf>::size);
341 a2 = __riscv_vrgather_vx_f32m2(aa, 2, unpacket_traits<Packet2Xf>::size);
342 a3 = __riscv_vrgather_vx_f32m2(aa, 3, unpacket_traits<Packet2Xf>::size);
346EIGEN_STRONG_INLINE Packet2Xf padd<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
347 return __riscv_vfadd_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
351EIGEN_STRONG_INLINE Packet2Xf psub<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
352 return __riscv_vfsub_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
356EIGEN_STRONG_INLINE Packet2Xf pnegate(
const Packet2Xf& a) {
357 return __riscv_vfneg_v_f32m2(a, unpacket_traits<Packet2Xf>::size);
361EIGEN_STRONG_INLINE Packet2Xf psignbit(
const Packet2Xf& a) {
362 return __riscv_vreinterpret_v_i32m2_f32m2(
363 __riscv_vsra_vx_i32m2(__riscv_vreinterpret_v_f32m2_i32m2(a), 31, unpacket_traits<Packet2Xi>::size));
367EIGEN_STRONG_INLINE Packet2Xf pmul<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
368 return __riscv_vfmul_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
372EIGEN_STRONG_INLINE Packet2Xf pdiv<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
373 return __riscv_vfdiv_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
377struct is_fused_madd<Packet2Xf> : true_type {};
379EIGEN_STRONG_INLINE Packet2Xf pmadd(
const Packet2Xf& a,
const Packet2Xf& b,
const Packet2Xf& c) {
380 return __riscv_vfmadd_vv_f32m2(a, b, c, unpacket_traits<Packet2Xf>::size);
384EIGEN_STRONG_INLINE Packet2Xf pmsub(
const Packet2Xf& a,
const Packet2Xf& b,
const Packet2Xf& c) {
385 return __riscv_vfmsub_vv_f32m2(a, b, c, unpacket_traits<Packet2Xf>::size);
389EIGEN_STRONG_INLINE Packet2Xf pnmadd(
const Packet2Xf& a,
const Packet2Xf& b,
const Packet2Xf& c) {
390 return __riscv_vfnmsub_vv_f32m2(a, b, c, unpacket_traits<Packet2Xf>::size);
394EIGEN_STRONG_INLINE Packet2Xf pnmsub(
const Packet2Xf& a,
const Packet2Xf& b,
const Packet2Xf& c) {
395 return __riscv_vfnmadd_vv_f32m2(a, b, c, unpacket_traits<Packet2Xf>::size);
399struct pminmax_propagates_nan<Packet2Xf> : bool_constant<true> {};
402EIGEN_STRONG_INLINE Packet2Xf pmin<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
403 Packet2Xf nans = __riscv_vfmv_v_f_f32m2((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet2Xf>::size);
404 PacketMask16 mask = __riscv_vmfeq_vv_f32m2_b16(a, a, unpacket_traits<Packet2Xf>::size);
405 PacketMask16 mask2 = __riscv_vmfeq_vv_f32m2_b16(b, b, unpacket_traits<Packet2Xf>::size);
406 mask = __riscv_vmand_mm_b16(mask, mask2, unpacket_traits<Packet2Xf>::size);
408 return __riscv_vfmin_vv_f32m2_tumu(mask, nans, a, b, unpacket_traits<Packet2Xf>::size);
412EIGEN_STRONG_INLINE Packet2Xf pmin<PropagateNumbers, Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
413 return __riscv_vfmin_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
417EIGEN_STRONG_INLINE Packet2Xf pmax<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
418 Packet2Xf nans = __riscv_vfmv_v_f_f32m2((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet2Xf>::size);
419 PacketMask16 mask = __riscv_vmfeq_vv_f32m2_b16(a, a, unpacket_traits<Packet2Xf>::size);
420 PacketMask16 mask2 = __riscv_vmfeq_vv_f32m2_b16(b, b, unpacket_traits<Packet2Xf>::size);
421 mask = __riscv_vmand_mm_b16(mask, mask2, unpacket_traits<Packet2Xf>::size);
423 return __riscv_vfmax_vv_f32m2_tumu(mask, nans, a, b, unpacket_traits<Packet2Xf>::size);
427EIGEN_STRONG_INLINE Packet2Xf pmax<PropagateNumbers, Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
428 return __riscv_vfmax_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
432EIGEN_STRONG_INLINE Packet2Xf pcmp_le<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
433 PacketMask16 mask = __riscv_vmfle_vv_f32m2_b16(a, b, unpacket_traits<Packet2Xf>::size);
434 return __riscv_vmerge_vvm_f32m2(pzero<Packet2Xf>(a), ptrue<Packet2Xf>(a), mask, unpacket_traits<Packet2Xf>::size);
438EIGEN_STRONG_INLINE Packet2Xf pcmp_lt<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
439 PacketMask16 mask = __riscv_vmflt_vv_f32m2_b16(a, b, unpacket_traits<Packet2Xf>::size);
440 return __riscv_vmerge_vvm_f32m2(pzero<Packet2Xf>(a), ptrue<Packet2Xf>(a), mask, unpacket_traits<Packet2Xf>::size);
444EIGEN_STRONG_INLINE Packet2Xf pcmp_eq<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
445 PacketMask16 mask = __riscv_vmfeq_vv_f32m2_b16(a, b, unpacket_traits<Packet2Xf>::size);
446 return __riscv_vmerge_vvm_f32m2(pzero<Packet2Xf>(a), ptrue<Packet2Xf>(a), mask, unpacket_traits<Packet2Xf>::size);
450EIGEN_STRONG_INLINE Packet2Xf pcmp_lt_or_nan<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
451 PacketMask16 mask = __riscv_vmfge_vv_f32m2_b16(a, b, unpacket_traits<Packet2Xf>::size);
452 return __riscv_vfmerge_vfm_f32m2(ptrue<Packet2Xf>(a), 0.0f, mask, unpacket_traits<Packet2Xf>::size);
455EIGEN_STRONG_INLINE Packet2Xf pselect(
const PacketMask16& mask,
const Packet2Xf& a,
const Packet2Xf& b) {
456 return __riscv_vmerge_vvm_f32m2(b, a, mask, unpacket_traits<Packet2Xf>::size);
459EIGEN_STRONG_INLINE Packet2Xf pselect(
const Packet2Xf& mask,
const Packet2Xf& a,
const Packet2Xf& b) {
461 __riscv_vmsne_vx_i32m2_b16(__riscv_vreinterpret_v_f32m2_i32m2(mask), 0, unpacket_traits<Packet2Xf>::size);
462 return __riscv_vmerge_vvm_f32m2(b, a, mask2, unpacket_traits<Packet2Xf>::size);
467EIGEN_STRONG_INLINE Packet2Xf pand<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
468 return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vand_vv_u32m2(
469 __riscv_vreinterpret_v_f32m2_u32m2(a), __riscv_vreinterpret_v_f32m2_u32m2(b), unpacket_traits<Packet2Xf>::size));
473EIGEN_STRONG_INLINE Packet2Xf por<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
474 return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vor_vv_u32m2(
475 __riscv_vreinterpret_v_f32m2_u32m2(a), __riscv_vreinterpret_v_f32m2_u32m2(b), unpacket_traits<Packet2Xf>::size));
479EIGEN_STRONG_INLINE Packet2Xf pxor<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
480 return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vxor_vv_u32m2(
481 __riscv_vreinterpret_v_f32m2_u32m2(a), __riscv_vreinterpret_v_f32m2_u32m2(b), unpacket_traits<Packet2Xf>::size));
485EIGEN_STRONG_INLINE Packet2Xf pandnot<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& b) {
487 return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vand_vv_u32m2(
488 __riscv_vreinterpret_v_f32m2_u32m2(a),
489 __riscv_vnot_v_u32m2(__riscv_vreinterpret_v_f32m2_u32m2(b), unpacket_traits<Packet2Xf>::size),
490 unpacket_traits<Packet2Xf>::size));
492 return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vandn_vv_u32m2(
493 __riscv_vreinterpret_v_f32m2_u32m2(a), __riscv_vreinterpret_v_f32m2_u32m2(b), unpacket_traits<Packet2Xi>::size));
498EIGEN_STRONG_INLINE Packet2Xf pnot<Packet2Xf>(
const Packet2Xf& a) {
499 return __riscv_vreinterpret_v_u32m2_f32m2(
500 __riscv_vnot_v_u32m2(__riscv_vreinterpret_v_f32m2_u32m2(a), unpacket_traits<Packet2Xf>::size));
504EIGEN_STRONG_INLINE Packet2Xf pload<Packet2Xf>(
const float* from) {
505 EIGEN_DEBUG_ALIGNED_LOAD
return __riscv_vle32_v_f32m2(from, unpacket_traits<Packet2Xf>::size);
509EIGEN_STRONG_INLINE Packet2Xf ploadu<Packet2Xf>(
const float* from) {
510 EIGEN_DEBUG_UNALIGNED_LOAD
return __riscv_vle32_v_f32m2(from, unpacket_traits<Packet2Xf>::size);
513EIGEN_STRONG_INLINE Packet4Xf pdup(
const Packet2Xf& a) {
514 Packet4Xul data = __riscv_vwcvtu_x_x_v_u64m4(__riscv_vreinterpret_v_f32m2_u32m2(a), unpacket_traits<Packet2Xi>::size);
515 return __riscv_vreinterpret_v_u64m4_f32m4(__riscv_vadd_vv_u64m4(
516 __riscv_vsll_vx_u64m4(data, 32, unpacket_traits<Packet4Xl>::size), data, unpacket_traits<Packet4Xl>::size));
520EIGEN_STRONG_INLINE Packet2Xf ploaddup<Packet2Xf>(
const float* from) {
521 Packet2Xul data = __riscv_vlmul_trunc_v_u64m4_u64m2(__riscv_vwcvtu_x_x_v_u64m4(
522 __riscv_vreinterpret_v_f32m2_u32m2(__riscv_vle32_v_f32m2(from, unpacket_traits<Packet2Xf>::size / 2)),
523 unpacket_traits<Packet2Xf>::size / 2));
524 return __riscv_vreinterpret_v_u64m2_f32m2(__riscv_vadd_vv_u64m2(
525 __riscv_vsll_vx_u64m2(data, 32, unpacket_traits<Packet2Xl>::size), data, unpacket_traits<Packet2Xl>::size));
529EIGEN_STRONG_INLINE Packet2Xf ploadquad<Packet2Xf>(
const float* from) {
531 __riscv_vsrl_vx_u32m2(__riscv_vid_v_u32m2(unpacket_traits<Packet2Xf>::size), 2, unpacket_traits<Packet2Xf>::size);
532 return __riscv_vrgather_vv_f32m2(pload<Packet2Xf>(from), idx, unpacket_traits<Packet2Xf>::size);
536EIGEN_STRONG_INLINE
void pstore<float>(
float* to,
const Packet2Xf& from) {
537 EIGEN_DEBUG_ALIGNED_STORE __riscv_vse32_v_f32m2(to, from, unpacket_traits<Packet2Xf>::size);
541EIGEN_STRONG_INLINE
void pstoreu<float>(
float* to,
const Packet2Xf& from) {
542 EIGEN_DEBUG_UNALIGNED_STORE __riscv_vse32_v_f32m2(to, from, unpacket_traits<Packet2Xf>::size);
546EIGEN_DEVICE_FUNC
inline Packet2Xf pgather<float, Packet2Xf>(
const float* from, Index stride) {
547 return __riscv_vlse32_v_f32m2(from, stride *
sizeof(
float), unpacket_traits<Packet2Xf>::size);
551EIGEN_DEVICE_FUNC
inline void pscatter<float, Packet2Xf>(
float* to,
const Packet2Xf& from, Index stride) {
552 __riscv_vsse32(to, stride *
sizeof(
float), from, unpacket_traits<Packet2Xf>::size);
556EIGEN_STRONG_INLINE
float pfirst<Packet2Xf>(
const Packet2Xf& a) {
557 return __riscv_vfmv_f_s_f32m2_f32(a);
561EIGEN_STRONG_INLINE Packet2Xf psqrt(
const Packet2Xf& a) {
562 return __riscv_vfsqrt_v_f32m2(a, unpacket_traits<Packet2Xf>::size);
566EIGEN_STRONG_INLINE Packet2Xf print<Packet2Xf>(
const Packet2Xf& a) {
567 const Packet2Xf limit = pset1<Packet2Xf>(
static_cast<float>(1 << 23));
568 const Packet2Xf abs_a = pabs(a);
570 PacketMask16 mask = __riscv_vmfne_vv_f32m2_b16(a, a, unpacket_traits<Packet2Xf>::size);
571 const Packet2Xf x = __riscv_vfadd_vv_f32m2_tumu(mask, a, a, a, unpacket_traits<Packet2Xf>::size);
572 const Packet2Xf new_x = __riscv_vfcvt_f_x_v_f32m2(__riscv_vfcvt_x_f_v_i32m2(a, unpacket_traits<Packet2Xf>::size),
573 unpacket_traits<Packet2Xf>::size);
575 mask = __riscv_vmflt_vv_f32m2_b16(abs_a, limit, unpacket_traits<Packet2Xf>::size);
576 Packet2Xf signed_x = __riscv_vfsgnj_vv_f32m2(new_x, x, unpacket_traits<Packet2Xf>::size);
577 return __riscv_vmerge_vvm_f32m2(x, signed_x, mask, unpacket_traits<Packet2Xf>::size);
581EIGEN_STRONG_INLINE Packet2Xf pfloor<Packet2Xf>(
const Packet2Xf& a) {
582 Packet2Xf tmp = print<Packet2Xf>(a);
584 PacketMask16 mask = __riscv_vmflt_vv_f32m2_b16(a, tmp, unpacket_traits<Packet2Xf>::size);
585 return __riscv_vfsub_vf_f32m2_tumu(mask, tmp, tmp, 1.0f, unpacket_traits<Packet2Xf>::size);
589EIGEN_STRONG_INLINE Packet2Xf preverse(
const Packet2Xf& a) {
590 Packet2Xu idx = __riscv_vrsub_vx_u32m2(__riscv_vid_v_u32m2(unpacket_traits<Packet2Xf>::size),
591 unpacket_traits<Packet2Xf>::size - 1, unpacket_traits<Packet2Xf>::size);
592 return __riscv_vrgather_vv_f32m2(a, idx, unpacket_traits<Packet2Xf>::size);
596EIGEN_STRONG_INLINE Packet2Xf pfrexp<Packet2Xf>(
const Packet2Xf& a, Packet2Xf& exponent) {
597 return pfrexp_generic(a, exponent);
601EIGEN_STRONG_INLINE
float predux<Packet2Xf>(
const Packet2Xf& a) {
602 return __riscv_vfmv_f(__riscv_vfredusum_vs_f32m2_f32m1(
603 a, __riscv_vfmv_v_f_f32m1(0.0f, unpacket_traits<Packet2Xf>::size / 2), unpacket_traits<Packet2Xf>::size));
607EIGEN_STRONG_INLINE
bool predux_any(
const Packet2Xf& a) {
608 const PacketMask16 mask =
609 __riscv_vmsne_vx_u32m2_b16(__riscv_vreinterpret_v_f32m2_u32m2(a), 0, unpacket_traits<Packet2Xf>::size);
610 return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet2Xf>::size) != 0;
614EIGEN_STRONG_INLINE
bool predux_all(
const Packet2Xf& a) {
615 const PacketMask16 mask = __riscv_vmfeq_vf_f32m2_b16(a, 0.0f, unpacket_traits<Packet2Xf>::size);
616 return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet2Xf>::size) == 0;
620EIGEN_STRONG_INLINE Index predux_count(
const Packet2Xf& a) {
621 const PacketMask16 mask = __riscv_vmfne_vf_f32m2_b16(a, 0.0f, unpacket_traits<Packet2Xf>::size);
622 return static_cast<Index
>(__riscv_vcpop_m_b16(mask, unpacket_traits<Packet2Xf>::size));
626EIGEN_STRONG_INLINE
float predux_mul<Packet2Xf>(
const Packet2Xf& a) {
627 return predux_mul<Packet1Xf>(__riscv_vfmul_vv_f32m1(
628 __riscv_vget_v_f32m2_f32m1(a, 0), __riscv_vget_v_f32m2_f32m1(a, 1), unpacket_traits<Packet1Xf>::size));
634EIGEN_STRONG_INLINE
float predux_min<Packet2Xf>(
const Packet2Xf& a) {
635 return __riscv_vfmv_f(
636 __riscv_vfredmin_vs_f32m2_f32m1(a, __riscv_vget_v_f32m2_f32m1(a, 0), unpacket_traits<Packet2Xf>::size));
640EIGEN_STRONG_INLINE
float predux_max<Packet2Xf>(
const Packet2Xf& a) {
641 return __riscv_vfmv_f(
642 __riscv_vfredmax_vs_f32m2_f32m1(a, __riscv_vget_v_f32m2_f32m1(a, 0), unpacket_traits<Packet2Xf>::size));
646EIGEN_STRONG_INLINE Packet1Xf predux_half(
const Packet2Xf& a) {
647 return Packet1Xf(__riscv_vfadd_vv_f32m1(__riscv_vget_v_f32m2_f32m1(a, 0), __riscv_vget_v_f32m2_f32m1(a, 1),
648 unpacket_traits<Packet1Xf>::size));
652EIGEN_DEVICE_FUNC
inline void ptranspose(PacketBlock<Packet2Xf, N>& kernel) {
653 float buffer[unpacket_traits<Packet2Xf>::size * N];
656 for (i = 0; i < N; i++) {
657 __riscv_vsse32(&buffer[i], N *
sizeof(
float), kernel.packet[i], unpacket_traits<Packet2Xf>::size);
660 for (i = 0; i < N; i++) {
662 __riscv_vle32_v_f32m2(&buffer[i * unpacket_traits<Packet2Xf>::size], unpacket_traits<Packet2Xf>::size);
667EIGEN_STRONG_INLINE Packet2Xf pldexp<Packet2Xf>(
const Packet2Xf& a,
const Packet2Xf& exponent) {
668 return pldexp_generic(a, exponent);
671template <
typename Packet = Packet2Xf>
673 std::enable_if_t<std::is_same<Packet, Packet2Xf>::value && (unpacket_traits<Packet2Xf>::size % 8) == 0, Packet1Xf>
674 predux_half(
const Packet2Xf& a) {
675 return __riscv_vfadd_vv_f32m1(__riscv_vget_v_f32m2_f32m1(a, 0), __riscv_vget_v_f32m2_f32m1(a, 1),
676 unpacket_traits<Packet1Xf>::size);
682EIGEN_STRONG_INLINE Packet2Xl pset1<Packet2Xl>(
const numext::int64_t& from) {
683 return __riscv_vmv_v_x_i64m2(from, unpacket_traits<Packet2Xl>::size);
687EIGEN_STRONG_INLINE Packet2Xl plset<Packet2Xl>(
const numext::int64_t& a) {
688 Packet2Xl idx = __riscv_vreinterpret_v_u64m2_i64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xl>::size));
689 return __riscv_vadd_vx_i64m2(idx, a, unpacket_traits<Packet2Xl>::size);
693EIGEN_STRONG_INLINE Packet2Xl pzero<Packet2Xl>(
const Packet2Xl& ) {
694 return __riscv_vmv_v_x_i64m2(0, unpacket_traits<Packet2Xl>::size);
698EIGEN_STRONG_INLINE Packet2Xl padd<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
699 return __riscv_vadd_vv_i64m2(a, b, unpacket_traits<Packet2Xl>::size);
703EIGEN_STRONG_INLINE Packet2Xl psub<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
704 return __riscv_vsub(a, b, unpacket_traits<Packet2Xl>::size);
708EIGEN_STRONG_INLINE Packet2Xl pnegate(
const Packet2Xl& a) {
709 return __riscv_vneg(a, unpacket_traits<Packet2Xl>::size);
713EIGEN_STRONG_INLINE Packet2Xl pmul<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
714 return __riscv_vmul(a, b, unpacket_traits<Packet2Xl>::size);
718EIGEN_STRONG_INLINE Packet2Xl pdiv<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
719 return __riscv_vdiv(a, b, unpacket_traits<Packet2Xl>::size);
723EIGEN_STRONG_INLINE Packet2Xl pmadd(
const Packet2Xl& a,
const Packet2Xl& b,
const Packet2Xl& c) {
724 return __riscv_vmadd(a, b, c, unpacket_traits<Packet2Xl>::size);
728EIGEN_STRONG_INLINE Packet2Xl pmsub(
const Packet2Xl& a,
const Packet2Xl& b,
const Packet2Xl& c) {
729 return __riscv_vmadd(a, b, pnegate(c), unpacket_traits<Packet2Xl>::size);
733EIGEN_STRONG_INLINE Packet2Xl pnmadd(
const Packet2Xl& a,
const Packet2Xl& b,
const Packet2Xl& c) {
734 return __riscv_vnmsub_vv_i64m2(a, b, c, unpacket_traits<Packet2Xl>::size);
738EIGEN_STRONG_INLINE Packet2Xl pnmsub(
const Packet2Xl& a,
const Packet2Xl& b,
const Packet2Xl& c) {
739 return __riscv_vnmsub_vv_i64m2(a, b, pnegate(c), unpacket_traits<Packet2Xl>::size);
743EIGEN_STRONG_INLINE Packet2Xl pmin<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
744 return __riscv_vmin(a, b, unpacket_traits<Packet2Xl>::size);
748EIGEN_STRONG_INLINE Packet2Xl pmax<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
749 return __riscv_vmax(a, b, unpacket_traits<Packet2Xl>::size);
753EIGEN_STRONG_INLINE Packet2Xl pcmp_le<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
754 PacketMask32 mask = __riscv_vmsle_vv_i64m2_b32(a, b, unpacket_traits<Packet2Xl>::size);
755 return __riscv_vmerge_vxm_i64m2(pzero(a), 0xffffffffffffffff, mask, unpacket_traits<Packet2Xl>::size);
759EIGEN_STRONG_INLINE Packet2Xl pcmp_lt<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
760 PacketMask32 mask = __riscv_vmslt_vv_i64m2_b32(a, b, unpacket_traits<Packet2Xl>::size);
761 return __riscv_vmerge_vxm_i64m2(pzero(a), 0xffffffffffffffff, mask, unpacket_traits<Packet2Xl>::size);
765EIGEN_STRONG_INLINE Packet2Xl pcmp_eq<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
766 PacketMask32 mask = __riscv_vmseq_vv_i64m2_b32(a, b, unpacket_traits<Packet2Xl>::size);
767 return __riscv_vmerge_vxm_i64m2(pzero(a), 0xffffffffffffffff, mask, unpacket_traits<Packet2Xl>::size);
771EIGEN_STRONG_INLINE Packet2Xl ptrue<Packet2Xl>(
const Packet2Xl& ) {
772 return __riscv_vmv_v_x_i64m2(0xffffffffffffffffu, unpacket_traits<Packet2Xl>::size);
776EIGEN_STRONG_INLINE Packet2Xl pand<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
777 return __riscv_vand_vv_i64m2(a, b, unpacket_traits<Packet2Xl>::size);
781EIGEN_STRONG_INLINE Packet2Xl por<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
782 return __riscv_vor_vv_i64m2(a, b, unpacket_traits<Packet2Xl>::size);
786EIGEN_STRONG_INLINE Packet2Xl pnot<Packet2Xl>(
const Packet2Xl& a) {
787 return __riscv_vnot_v_i64m2(a, unpacket_traits<Packet2Xl>::size);
791EIGEN_STRONG_INLINE Packet2Xl pxor<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
792 return __riscv_vxor_vv_i64m2(a, b, unpacket_traits<Packet2Xl>::size);
796EIGEN_STRONG_INLINE Packet2Xl pandnot<Packet2Xl>(
const Packet2Xl& a,
const Packet2Xl& b) {
798 return __riscv_vand_vv_i64m2(a, __riscv_vnot_v_i64m2(b, unpacket_traits<Packet2Xl>::size),
799 unpacket_traits<Packet2Xl>::size);
801 return __riscv_vreinterpret_v_u64m2_i64m2(__riscv_vandn_vv_u64m2(
802 __riscv_vreinterpret_v_i64m2_u64m2(a), __riscv_vreinterpret_v_i64m2_u64m2(b), unpacket_traits<Packet2Xl>::size));
807EIGEN_STRONG_INLINE Packet2Xl parithmetic_shift_right(
const Packet2Xl& a) {
808 return __riscv_vsra_vx_i64m2(a, N, unpacket_traits<Packet2Xl>::size);
812EIGEN_STRONG_INLINE Packet2Xl plogical_shift_right(
const Packet2Xl& a) {
813 return __riscv_vreinterpret_i64m2(
814 __riscv_vsrl_vx_u64m2(__riscv_vreinterpret_u64m2(a), N, unpacket_traits<Packet2Xl>::size));
818EIGEN_STRONG_INLINE Packet2Xl plogical_shift_left(
const Packet2Xl& a) {
819 return __riscv_vsll_vx_i64m2(a, N, unpacket_traits<Packet2Xl>::size);
823EIGEN_STRONG_INLINE Packet2Xl pload<Packet2Xl>(
const numext::int64_t* from) {
824 EIGEN_DEBUG_ALIGNED_LOAD
return __riscv_vle64_v_i64m2(from, unpacket_traits<Packet2Xl>::size);
828EIGEN_STRONG_INLINE Packet2Xl ploadu<Packet2Xl>(
const numext::int64_t* from) {
829 EIGEN_DEBUG_UNALIGNED_LOAD
return __riscv_vle64_v_i64m2(from, unpacket_traits<Packet2Xl>::size);
833EIGEN_STRONG_INLINE Packet2Xl ploaddup<Packet2Xl>(
const numext::int64_t* from) {
835 __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xl>::size), 1, unpacket_traits<Packet2Xl>::size);
836 return __riscv_vrgather_vv_i64m2(__riscv_vle64_v_i64m2(from, unpacket_traits<Packet2Xl>::size / 2), idx,
837 unpacket_traits<Packet2Xl>::size);
841EIGEN_STRONG_INLINE Packet2Xl ploadquad<Packet2Xl>(
const numext::int64_t* from) {
843 __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xl>::size), 2, unpacket_traits<Packet2Xl>::size);
844 return __riscv_vrgather_vv_i64m2(pload<Packet2Xl>(from), idx, unpacket_traits<Packet2Xl>::size);
848EIGEN_STRONG_INLINE
void pstore<numext::int64_t>(numext::int64_t* to,
const Packet2Xl& from) {
849 EIGEN_DEBUG_ALIGNED_STORE __riscv_vse64_v_i64m2(to, from, unpacket_traits<Packet2Xl>::size);
853EIGEN_STRONG_INLINE
void pstoreu<numext::int64_t>(numext::int64_t* to,
const Packet2Xl& from) {
854 EIGEN_DEBUG_UNALIGNED_STORE __riscv_vse64_v_i64m2(to, from, unpacket_traits<Packet2Xl>::size);
858EIGEN_DEVICE_FUNC
inline Packet2Xl pgather<numext::int64_t, Packet2Xl>(
const numext::int64_t* from, Index stride) {
859 return __riscv_vlse64_v_i64m2(from, stride *
sizeof(numext::int64_t), unpacket_traits<Packet2Xl>::size);
863EIGEN_DEVICE_FUNC
inline void pscatter<numext::int64_t, Packet2Xl>(numext::int64_t* to,
const Packet2Xl& from,
865 __riscv_vsse64(to, stride *
sizeof(numext::int64_t), from, unpacket_traits<Packet2Xl>::size);
869EIGEN_STRONG_INLINE numext::int64_t pfirst<Packet2Xl>(
const Packet2Xl& a) {
870 return __riscv_vmv_x_s_i64m2_i64(a);
874EIGEN_STRONG_INLINE Packet2Xl preverse(
const Packet2Xl& a) {
875 Packet2Xul idx = __riscv_vrsub_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xl>::size),
876 unpacket_traits<Packet2Xl>::size - 1, unpacket_traits<Packet2Xl>::size);
877 return __riscv_vrgather_vv_i64m2(a, idx, unpacket_traits<Packet2Xl>::size);
881EIGEN_STRONG_INLINE Packet2Xl pabs(
const Packet2Xl& a) {
882 Packet2Xl mask = __riscv_vsra_vx_i64m2(a, 63, unpacket_traits<Packet2Xl>::size);
883 return __riscv_vsub_vv_i64m2(__riscv_vxor_vv_i64m2(a, mask, unpacket_traits<Packet2Xl>::size), mask,
884 unpacket_traits<Packet2Xl>::size);
888EIGEN_STRONG_INLINE numext::int64_t predux<Packet2Xl>(
const Packet2Xl& a) {
889 return __riscv_vmv_x(__riscv_vredsum_vs_i64m2_i64m1(a, __riscv_vmv_v_x_i64m1(0, unpacket_traits<Packet2Xl>::size / 2),
890 unpacket_traits<Packet2Xl>::size));
894EIGEN_STRONG_INLINE
bool predux_all(
const Packet2Xl& a) {
895 const PacketMask32 mask = __riscv_vmseq_vx_i64m2_b32(a, 0, unpacket_traits<Packet2Xl>::size);
896 return __riscv_vcpop_m_b32(mask, unpacket_traits<Packet2Xl>::size) == 0;
900EIGEN_STRONG_INLINE numext::int64_t predux_mul<Packet2Xl>(
const Packet2Xl& a) {
901 return predux_mul<Packet1Xl>(__riscv_vmul_vv_i64m1(__riscv_vget_v_i64m2_i64m1(a, 0), __riscv_vget_v_i64m2_i64m1(a, 1),
902 unpacket_traits<Packet1Xl>::size));
906EIGEN_STRONG_INLINE numext::int64_t predux_min<Packet2Xl>(
const Packet2Xl& a) {
907 return __riscv_vmv_x(__riscv_vredmin_vs_i64m2_i64m1(
908 a, __riscv_vmv_v_x_i64m1((std::numeric_limits<numext::int64_t>::max)(), unpacket_traits<Packet2Xl>::size / 2),
909 unpacket_traits<Packet2Xl>::size));
913EIGEN_STRONG_INLINE numext::int64_t predux_max<Packet2Xl>(
const Packet2Xl& a) {
914 return __riscv_vmv_x(__riscv_vredmax_vs_i64m2_i64m1(
915 a, __riscv_vmv_v_x_i64m1((std::numeric_limits<numext::int64_t>::min)(), unpacket_traits<Packet2Xl>::size / 2),
916 unpacket_traits<Packet2Xl>::size));
920EIGEN_DEVICE_FUNC
inline void ptranspose(PacketBlock<Packet2Xl, N>& kernel) {
921 numext::int64_t buffer[unpacket_traits<Packet2Xl>::size * N] = {0};
924 for (i = 0; i < N; i++) {
925 __riscv_vsse64(&buffer[i], N *
sizeof(numext::int64_t), kernel.packet[i], unpacket_traits<Packet2Xl>::size);
927 for (i = 0; i < N; i++) {
929 __riscv_vle64_v_i64m2(&buffer[i * unpacket_traits<Packet2Xl>::size], unpacket_traits<Packet2Xl>::size);
933template <
typename Packet = Packet2Xl>
935 std::enable_if_t<std::is_same<Packet, Packet2Xl>::value && (unpacket_traits<Packet2Xl>::size % 8) == 0, Packet1Xl>
936 predux_half(
const Packet2Xl& a) {
937 return __riscv_vadd_vv_i64m1(__riscv_vget_v_i64m2_i64m1(a, 0), __riscv_vget_v_i64m2_i64m1(a, 1),
938 unpacket_traits<Packet1Xl>::size);
944EIGEN_STRONG_INLINE Packet2Xd ptrue<Packet2Xd>(
const Packet2Xd& ) {
946 __riscv_vreinterpret_f64m2(__riscv_vmv_v_x_u64m2(0xffffffffffffffffu, unpacket_traits<Packet2Xd>::size));
947 EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
952EIGEN_STRONG_INLINE Packet2Xd pzero<Packet2Xd>(
const Packet2Xd& ) {
953 return __riscv_vfmv_v_f_f64m2(0.0, unpacket_traits<Packet2Xd>::size);
957EIGEN_STRONG_INLINE Packet2Xd pabs(
const Packet2Xd& a) {
958 return __riscv_vfabs_v_f64m2(a, unpacket_traits<Packet2Xd>::size);
962EIGEN_STRONG_INLINE Packet2Xd pabsdiff(
const Packet2Xd& a,
const Packet2Xd& b) {
963 return __riscv_vfabs_v_f64m2(__riscv_vfsub_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size),
964 unpacket_traits<Packet2Xd>::size);
968EIGEN_STRONG_INLINE Packet2Xd pset1<Packet2Xd>(
const double& from) {
969 return __riscv_vfmv_v_f_f64m2(from, unpacket_traits<Packet2Xd>::size);
973EIGEN_STRONG_INLINE Packet2Xd pset1frombits<Packet2Xd>(numext::uint64_t from) {
974 return __riscv_vreinterpret_f64m2(__riscv_vmv_v_x_u64m2(from, unpacket_traits<Packet2Xd>::size));
978EIGEN_STRONG_INLINE Packet2Xd plset<Packet2Xd>(
const double& a) {
979 Packet2Xd idx = __riscv_vfcvt_f_x_v_f64m2(
980 __riscv_vreinterpret_v_u64m2_i64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet4Xi>::size)),
981 unpacket_traits<Packet2Xd>::size);
982 return __riscv_vfadd_vf_f64m2(idx, a, unpacket_traits<Packet2Xd>::size);
986EIGEN_STRONG_INLINE
void pbroadcast4<Packet2Xd>(
const double* a, Packet2Xd& a0, Packet2Xd& a1, Packet2Xd& a2,
989 EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
990 aa = __riscv_vlmul_ext_f64m2(__riscv_vle64_v_f64m1(a, 4));
992 aa = __riscv_vle64_v_f64m2(a, 4);
994 a0 = __riscv_vrgather_vx_f64m2(aa, 0, unpacket_traits<Packet2Xd>::size);
995 a1 = __riscv_vrgather_vx_f64m2(aa, 1, unpacket_traits<Packet2Xd>::size);
996 a2 = __riscv_vrgather_vx_f64m2(aa, 2, unpacket_traits<Packet2Xd>::size);
997 a3 = __riscv_vrgather_vx_f64m2(aa, 3, unpacket_traits<Packet2Xd>::size);
1001EIGEN_STRONG_INLINE Packet2Xd padd<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1002 return __riscv_vfadd_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
1006EIGEN_STRONG_INLINE Packet2Xd psub<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1007 return __riscv_vfsub_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
1011EIGEN_STRONG_INLINE Packet2Xd pnegate(
const Packet2Xd& a) {
1012 return __riscv_vfneg_v_f64m2(a, unpacket_traits<Packet2Xd>::size);
1016EIGEN_STRONG_INLINE Packet2Xd psignbit(
const Packet2Xd& a) {
1017 return __riscv_vreinterpret_v_i64m2_f64m2(
1018 __riscv_vsra_vx_i64m2(__riscv_vreinterpret_v_f64m2_i64m2(a), 63, unpacket_traits<Packet2Xl>::size));
1022EIGEN_STRONG_INLINE Packet2Xd pmul<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1023 return __riscv_vfmul_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
1027EIGEN_STRONG_INLINE Packet2Xd pdiv<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1028 return __riscv_vfdiv_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
1032struct is_fused_madd<Packet2Xd> : true_type {};
1034EIGEN_STRONG_INLINE Packet2Xd pmadd(
const Packet2Xd& a,
const Packet2Xd& b,
const Packet2Xd& c) {
1035 return __riscv_vfmadd_vv_f64m2(a, b, c, unpacket_traits<Packet2Xd>::size);
1039EIGEN_STRONG_INLINE Packet2Xd pmsub(
const Packet2Xd& a,
const Packet2Xd& b,
const Packet2Xd& c) {
1040 return __riscv_vfmsub_vv_f64m2(a, b, c, unpacket_traits<Packet2Xd>::size);
1044EIGEN_STRONG_INLINE Packet2Xd pnmadd(
const Packet2Xd& a,
const Packet2Xd& b,
const Packet2Xd& c) {
1045 return __riscv_vfnmsub_vv_f64m2(a, b, c, unpacket_traits<Packet2Xd>::size);
1049EIGEN_STRONG_INLINE Packet2Xd pnmsub(
const Packet2Xd& a,
const Packet2Xd& b,
const Packet2Xd& c) {
1050 return __riscv_vfnmadd_vv_f64m2(a, b, c, unpacket_traits<Packet2Xd>::size);
1054struct pminmax_propagates_nan<Packet2Xd> : bool_constant<true> {};
1057EIGEN_STRONG_INLINE Packet2Xd pmin<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1058 Packet2Xd nans = __riscv_vfmv_v_f_f64m2((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet2Xd>::size);
1059 PacketMask32 mask = __riscv_vmfeq_vv_f64m2_b32(a, a, unpacket_traits<Packet2Xd>::size);
1060 PacketMask32 mask2 = __riscv_vmfeq_vv_f64m2_b32(b, b, unpacket_traits<Packet2Xd>::size);
1061 mask = __riscv_vmand_mm_b32(mask, mask2, unpacket_traits<Packet2Xd>::size);
1063 return __riscv_vfmin_vv_f64m2_tumu(mask, nans, a, b, unpacket_traits<Packet2Xd>::size);
1067EIGEN_STRONG_INLINE Packet2Xd pmin<PropagateNumbers, Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1068 return __riscv_vfmin_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
1072EIGEN_STRONG_INLINE Packet2Xd pmax<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1073 Packet2Xd nans = __riscv_vfmv_v_f_f64m2((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet2Xd>::size);
1074 PacketMask32 mask = __riscv_vmfeq_vv_f64m2_b32(a, a, unpacket_traits<Packet2Xd>::size);
1075 PacketMask32 mask2 = __riscv_vmfeq_vv_f64m2_b32(b, b, unpacket_traits<Packet2Xd>::size);
1076 mask = __riscv_vmand_mm_b32(mask, mask2, unpacket_traits<Packet2Xd>::size);
1078 return __riscv_vfmax_vv_f64m2_tumu(mask, nans, a, b, unpacket_traits<Packet2Xd>::size);
1082EIGEN_STRONG_INLINE Packet2Xd pmax<PropagateNumbers, Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1083 return __riscv_vfmax_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
1087EIGEN_STRONG_INLINE Packet2Xd pcmp_le<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1088 PacketMask32 mask = __riscv_vmfle_vv_f64m2_b32(a, b, unpacket_traits<Packet2Xd>::size);
1089 return __riscv_vmerge_vvm_f64m2(pzero<Packet2Xd>(a), ptrue<Packet2Xd>(a), mask, unpacket_traits<Packet2Xd>::size);
1093EIGEN_STRONG_INLINE Packet2Xd pcmp_lt<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1094 PacketMask32 mask = __riscv_vmflt_vv_f64m2_b32(a, b, unpacket_traits<Packet2Xd>::size);
1095 return __riscv_vmerge_vvm_f64m2(pzero<Packet2Xd>(a), ptrue<Packet2Xd>(a), mask, unpacket_traits<Packet2Xd>::size);
1099EIGEN_STRONG_INLINE Packet2Xd pcmp_eq<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1100 PacketMask32 mask = __riscv_vmfeq_vv_f64m2_b32(a, b, unpacket_traits<Packet2Xd>::size);
1101 return __riscv_vmerge_vvm_f64m2(pzero<Packet2Xd>(a), ptrue<Packet2Xd>(a), mask, unpacket_traits<Packet2Xd>::size);
1105EIGEN_STRONG_INLINE Packet2Xd pcmp_lt_or_nan<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1106 PacketMask32 mask = __riscv_vmfge_vv_f64m2_b32(a, b, unpacket_traits<Packet2Xd>::size);
1107 return __riscv_vfmerge_vfm_f64m2(ptrue<Packet2Xd>(a), 0.0, mask, unpacket_traits<Packet2Xd>::size);
1110EIGEN_STRONG_INLINE Packet2Xd pselect(
const PacketMask32& mask,
const Packet2Xd& a,
const Packet2Xd& b) {
1111 return __riscv_vmerge_vvm_f64m2(b, a, mask, unpacket_traits<Packet2Xd>::size);
1114EIGEN_STRONG_INLINE Packet2Xd pselect(
const Packet2Xd& mask,
const Packet2Xd& a,
const Packet2Xd& b) {
1115 PacketMask32 mask2 =
1116 __riscv_vmsne_vx_i64m2_b32(__riscv_vreinterpret_v_f64m2_i64m2(mask), 0, unpacket_traits<Packet2Xd>::size);
1117 return __riscv_vmerge_vvm_f64m2(b, a, mask2, unpacket_traits<Packet2Xd>::size);
1122EIGEN_STRONG_INLINE Packet2Xd pand<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1123 return __riscv_vreinterpret_v_u64m2_f64m2(__riscv_vand_vv_u64m2(
1124 __riscv_vreinterpret_v_f64m2_u64m2(a), __riscv_vreinterpret_v_f64m2_u64m2(b), unpacket_traits<Packet2Xd>::size));
1128EIGEN_STRONG_INLINE Packet2Xd por<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1129 return __riscv_vreinterpret_v_u64m2_f64m2(__riscv_vor_vv_u64m2(
1130 __riscv_vreinterpret_v_f64m2_u64m2(a), __riscv_vreinterpret_v_f64m2_u64m2(b), unpacket_traits<Packet2Xd>::size));
1134EIGEN_STRONG_INLINE Packet2Xd pxor<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1135 return __riscv_vreinterpret_v_u64m2_f64m2(__riscv_vxor_vv_u64m2(
1136 __riscv_vreinterpret_v_f64m2_u64m2(a), __riscv_vreinterpret_v_f64m2_u64m2(b), unpacket_traits<Packet2Xd>::size));
1140EIGEN_STRONG_INLINE Packet2Xd pandnot<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& b) {
1142 return __riscv_vreinterpret_v_u64m2_f64m2(__riscv_vand_vv_u64m2(
1143 __riscv_vreinterpret_v_f64m2_u64m2(a),
1144 __riscv_vnot_v_u64m2(__riscv_vreinterpret_v_f64m2_u64m2(b), unpacket_traits<Packet2Xd>::size),
1145 unpacket_traits<Packet2Xd>::size));
1147 return __riscv_vreinterpret_v_u64m2_f64m2(__riscv_vandn_vv_u64m2(
1148 __riscv_vreinterpret_v_f64m2_u64m2(a), __riscv_vreinterpret_v_f64m2_u64m2(b), unpacket_traits<Packet2Xl>::size));
1153EIGEN_STRONG_INLINE Packet2Xd pnot<Packet2Xd>(
const Packet2Xd& a) {
1154 return __riscv_vreinterpret_v_u64m2_f64m2(
1155 __riscv_vnot_v_u64m2(__riscv_vreinterpret_v_f64m2_u64m2(a), unpacket_traits<Packet2Xd>::size));
1159EIGEN_STRONG_INLINE Packet2Xd pload<Packet2Xd>(
const double* from) {
1160 EIGEN_DEBUG_ALIGNED_LOAD
return __riscv_vle64_v_f64m2(from, unpacket_traits<Packet2Xd>::size);
1164EIGEN_STRONG_INLINE Packet2Xd ploadu<Packet2Xd>(
const double* from) {
1165 EIGEN_DEBUG_UNALIGNED_LOAD
return __riscv_vle64_v_f64m2(from, unpacket_traits<Packet2Xd>::size);
1168EIGEN_STRONG_INLINE Packet4Xd pdup(
const Packet2Xd& a) {
1170 __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 1, unpacket_traits<Packet4Xd>::size);
1171 return __riscv_vrgather_vv_f64m4(__riscv_vlmul_ext_v_f64m2_f64m4(a), idx, unpacket_traits<Packet4Xd>::size);
1175EIGEN_STRONG_INLINE Packet2Xd ploaddup<Packet2Xd>(
const double* from) {
1177 __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 1, unpacket_traits<Packet2Xd>::size);
1178 return __riscv_vrgather_vv_f64m2(__riscv_vlmul_ext_v_f64m1_f64m2(pload<Packet1Xd>(from)), idx,
1179 unpacket_traits<Packet2Xd>::size);
1183EIGEN_STRONG_INLINE Packet2Xd ploadquad<Packet2Xd>(
const double* from) {
1185 __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 2, unpacket_traits<Packet2Xd>::size);
1186 return __riscv_vrgather_vv_f64m2(__riscv_vlmul_ext_v_f64m1_f64m2(pload<Packet1Xd>(from)), idx,
1187 unpacket_traits<Packet2Xd>::size);
1191EIGEN_STRONG_INLINE
void pstore<double>(
double* to,
const Packet2Xd& from) {
1192 EIGEN_DEBUG_ALIGNED_STORE __riscv_vse64_v_f64m2(to, from, unpacket_traits<Packet2Xd>::size);
1196EIGEN_STRONG_INLINE
void pstoreu<double>(
double* to,
const Packet2Xd& from) {
1197 EIGEN_DEBUG_UNALIGNED_STORE __riscv_vse64_v_f64m2(to, from, unpacket_traits<Packet2Xd>::size);
1201EIGEN_DEVICE_FUNC
inline Packet2Xd pgather<double, Packet2Xd>(
const double* from, Index stride) {
1202 return __riscv_vlse64_v_f64m2(from, stride *
sizeof(
double), unpacket_traits<Packet2Xd>::size);
1206EIGEN_DEVICE_FUNC
inline void pscatter<double, Packet2Xd>(
double* to,
const Packet2Xd& from, Index stride) {
1207 __riscv_vsse64(to, stride *
sizeof(
double), from, unpacket_traits<Packet2Xd>::size);
1211EIGEN_STRONG_INLINE
double pfirst<Packet2Xd>(
const Packet2Xd& a) {
1212 return __riscv_vfmv_f_s_f64m2_f64(a);
1216EIGEN_STRONG_INLINE Packet2Xd psqrt(
const Packet2Xd& a) {
1217 return __riscv_vfsqrt_v_f64m2(a, unpacket_traits<Packet2Xd>::size);
1221EIGEN_STRONG_INLINE Packet2Xd print<Packet2Xd>(
const Packet2Xd& a) {
1222 const Packet2Xd limit = pset1<Packet2Xd>(
static_cast<double>(1ull << 52));
1223 const Packet2Xd abs_a = pabs(a);
1225 PacketMask32 mask = __riscv_vmfne_vv_f64m2_b32(a, a, unpacket_traits<Packet2Xd>::size);
1226 const Packet2Xd x = __riscv_vfadd_vv_f64m2_tumu(mask, a, a, a, unpacket_traits<Packet2Xd>::size);
1227 const Packet2Xd new_x = __riscv_vfcvt_f_x_v_f64m2(__riscv_vfcvt_x_f_v_i64m2(a, unpacket_traits<Packet2Xd>::size),
1228 unpacket_traits<Packet2Xd>::size);
1230 mask = __riscv_vmflt_vv_f64m2_b32(abs_a, limit, unpacket_traits<Packet2Xd>::size);
1231 Packet2Xd signed_x = __riscv_vfsgnj_vv_f64m2(new_x, x, unpacket_traits<Packet2Xd>::size);
1232 return __riscv_vmerge_vvm_f64m2(x, signed_x, mask, unpacket_traits<Packet2Xd>::size);
1236EIGEN_STRONG_INLINE Packet2Xd pfloor<Packet2Xd>(
const Packet2Xd& a) {
1237 Packet2Xd tmp = print<Packet2Xd>(a);
1239 PacketMask32 mask = __riscv_vmflt_vv_f64m2_b32(a, tmp, unpacket_traits<Packet2Xd>::size);
1240 return __riscv_vfsub_vf_f64m2_tumu(mask, tmp, tmp, 1.0, unpacket_traits<Packet2Xd>::size);
1244EIGEN_STRONG_INLINE Packet2Xd preverse(
const Packet2Xd& a) {
1245 Packet2Xul idx = __riscv_vrsub_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size),
1246 unpacket_traits<Packet2Xd>::size - 1, unpacket_traits<Packet2Xd>::size);
1247 return __riscv_vrgather_vv_f64m2(a, idx, unpacket_traits<Packet2Xd>::size);
1251EIGEN_STRONG_INLINE Packet2Xd pfrexp<Packet2Xd>(
const Packet2Xd& a, Packet2Xd& exponent) {
1252 return pfrexp_generic(a, exponent);
1256EIGEN_STRONG_INLINE
double predux<Packet2Xd>(
const Packet2Xd& a) {
1257 return __riscv_vfmv_f(__riscv_vfredusum_vs_f64m2_f64m1(
1258 a, __riscv_vfmv_v_f_f64m1(0.0, unpacket_traits<Packet2Xd>::size / 2), unpacket_traits<Packet2Xd>::size));
1262EIGEN_STRONG_INLINE
bool predux_any(
const Packet2Xd& a) {
1263 const PacketMask32 mask =
1264 __riscv_vmsne_vx_u64m2_b32(__riscv_vreinterpret_v_f64m2_u64m2(a), 0, unpacket_traits<Packet2Xd>::size);
1265 return __riscv_vcpop_m_b32(mask, unpacket_traits<Packet2Xd>::size) != 0;
1269EIGEN_STRONG_INLINE
bool predux_all(
const Packet2Xd& a) {
1270 const PacketMask32 mask = __riscv_vmfeq_vf_f64m2_b32(a, 0.0, unpacket_traits<Packet2Xd>::size);
1271 return __riscv_vcpop_m_b32(mask, unpacket_traits<Packet2Xd>::size) == 0;
1275EIGEN_STRONG_INLINE Index predux_count(
const Packet2Xd& a) {
1276 const PacketMask32 mask = __riscv_vmfne_vf_f64m2_b32(a, 0.0, unpacket_traits<Packet2Xd>::size);
1277 return static_cast<Index
>(__riscv_vcpop_m_b32(mask, unpacket_traits<Packet2Xd>::size));
1281EIGEN_STRONG_INLINE
double predux_mul<Packet2Xd>(
const Packet2Xd& a) {
1282 return predux_mul<Packet1Xd>(__riscv_vfmul_vv_f64m1(
1283 __riscv_vget_v_f64m2_f64m1(a, 0), __riscv_vget_v_f64m2_f64m1(a, 1), unpacket_traits<Packet1Xd>::size));
1287EIGEN_STRONG_INLINE
double predux_min<Packet2Xd>(
const Packet2Xd& a) {
1288 return __riscv_vfmv_f(
1289 __riscv_vfredmin_vs_f64m2_f64m1(a, __riscv_vget_v_f64m2_f64m1(a, 0), unpacket_traits<Packet2Xd>::size));
1293EIGEN_STRONG_INLINE
double predux_max<Packet2Xd>(
const Packet2Xd& a) {
1294 return __riscv_vfmv_f(
1295 __riscv_vfredmax_vs_f64m2_f64m1(a, __riscv_vget_v_f64m2_f64m1(a, 0), unpacket_traits<Packet2Xd>::size));
1298#if __riscv_v_min_vlen >= 256
1300EIGEN_STRONG_INLINE Packet1Xd predux_half(
const Packet2Xd& a) {
1301 return Packet1Xd(__riscv_vfadd_vv_f64m1(__riscv_vget_v_f64m2_f64m1(a, 0), __riscv_vget_v_f64m2_f64m1(a, 1),
1302 unpacket_traits<Packet1Xd>::size));
1307EIGEN_DEVICE_FUNC
inline void ptranspose(PacketBlock<Packet2Xd, N>& kernel) {
1308 double buffer[unpacket_traits<Packet2Xd>::size * N];
1311 for (i = 0; i < N; i++) {
1312 __riscv_vsse64(&buffer[i], N *
sizeof(
double), kernel.packet[i], unpacket_traits<Packet2Xd>::size);
1315 for (i = 0; i < N; i++) {
1317 __riscv_vle64_v_f64m2(&buffer[i * unpacket_traits<Packet2Xd>::size], unpacket_traits<Packet2Xd>::size);
1322EIGEN_STRONG_INLINE Packet2Xd pldexp<Packet2Xd>(
const Packet2Xd& a,
const Packet2Xd& exponent) {
1323 return pldexp_generic(a, exponent);
1326template <
typename Packet = Packet2Xd>
1328 std::enable_if_t<std::is_same<Packet, Packet2Xd>::value && (unpacket_traits<Packet2Xd>::size % 8) == 0, Packet1Xd>
1329 predux_half(
const Packet2Xd& a) {
1330 return __riscv_vfadd_vv_f64m1(__riscv_vget_v_f64m2_f64m1(a, 0), __riscv_vget_v_f64m2_f64m1(a, 1),
1331 unpacket_traits<Packet1Xd>::size);
1336EIGEN_STRONG_INLINE Packet2Xs __riscv_vreinterpret_v_u32m2_i16m2(
const Packet2Xu& a) {
1337 return __riscv_vreinterpret_v_i32m2_i16m2(__riscv_vreinterpret_v_u32m2_i32m2(a));
1341EIGEN_STRONG_INLINE Packet2Xs pset1<Packet2Xs>(
const numext::int16_t& from) {
1342 return __riscv_vmv_v_x_i16m2(from, unpacket_traits<Packet2Xs>::size);
1346EIGEN_STRONG_INLINE Packet2Xs plset<Packet2Xs>(
const numext::int16_t& a) {
1347 Packet2Xs idx = __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vid_v_u16m2(unpacket_traits<Packet2Xs>::size));
1348 return __riscv_vadd_vx_i16m2(idx, a, unpacket_traits<Packet2Xs>::size);
1352EIGEN_STRONG_INLINE Packet2Xs pzero<Packet2Xs>(
const Packet2Xs& ) {
1353 return __riscv_vmv_v_x_i16m2(0, unpacket_traits<Packet2Xs>::size);
1357EIGEN_STRONG_INLINE Packet2Xs padd<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1358 return __riscv_vadd_vv_i16m2(a, b, unpacket_traits<Packet2Xs>::size);
1362EIGEN_STRONG_INLINE Packet2Xs psub<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1363 return __riscv_vsub(a, b, unpacket_traits<Packet2Xs>::size);
1367EIGEN_STRONG_INLINE Packet2Xs pnegate(
const Packet2Xs& a) {
1368 return __riscv_vneg(a, unpacket_traits<Packet2Xs>::size);
1372EIGEN_STRONG_INLINE Packet2Xs pmul<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1373 return __riscv_vmul(a, b, unpacket_traits<Packet2Xs>::size);
1377EIGEN_STRONG_INLINE Packet2Xs pdiv<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1378 return __riscv_vdiv(a, b, unpacket_traits<Packet2Xs>::size);
1382EIGEN_STRONG_INLINE Packet2Xs pmadd(
const Packet2Xs& a,
const Packet2Xs& b,
const Packet2Xs& c) {
1383 return __riscv_vmadd(a, b, c, unpacket_traits<Packet2Xs>::size);
1387EIGEN_STRONG_INLINE Packet2Xs pmsub(
const Packet2Xs& a,
const Packet2Xs& b,
const Packet2Xs& c) {
1388 return __riscv_vmadd(a, b, pnegate(c), unpacket_traits<Packet2Xs>::size);
1392EIGEN_STRONG_INLINE Packet2Xs pnmadd(
const Packet2Xs& a,
const Packet2Xs& b,
const Packet2Xs& c) {
1393 return __riscv_vnmsub_vv_i16m2(a, b, c, unpacket_traits<Packet2Xs>::size);
1397EIGEN_STRONG_INLINE Packet2Xs pnmsub(
const Packet2Xs& a,
const Packet2Xs& b,
const Packet2Xs& c) {
1398 return __riscv_vnmsub_vv_i16m2(a, b, pnegate(c), unpacket_traits<Packet2Xs>::size);
1402EIGEN_STRONG_INLINE Packet2Xs pmin<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1403 return __riscv_vmin(a, b, unpacket_traits<Packet2Xs>::size);
1407EIGEN_STRONG_INLINE Packet2Xs pmax<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1408 return __riscv_vmax(a, b, unpacket_traits<Packet2Xs>::size);
1412EIGEN_STRONG_INLINE Packet2Xs pcmp_le<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1413 PacketMask8 mask = __riscv_vmsle_vv_i16m2_b8(a, b, unpacket_traits<Packet2Xs>::size);
1414 return __riscv_vmerge_vxm_i16m2(pzero(a),
static_cast<short>(0xffff), mask, unpacket_traits<Packet2Xs>::size);
1418EIGEN_STRONG_INLINE Packet2Xs pcmp_lt<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1419 PacketMask8 mask = __riscv_vmslt_vv_i16m2_b8(a, b, unpacket_traits<Packet2Xs>::size);
1420 return __riscv_vmerge_vxm_i16m2(pzero(a),
static_cast<short>(0xffff), mask, unpacket_traits<Packet2Xs>::size);
1424EIGEN_STRONG_INLINE Packet2Xs pcmp_eq<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1425 PacketMask8 mask = __riscv_vmseq_vv_i16m2_b8(a, b, unpacket_traits<Packet2Xs>::size);
1426 return __riscv_vmerge_vxm_i16m2(pzero(a),
static_cast<short>(0xffff), mask, unpacket_traits<Packet2Xs>::size);
1430EIGEN_STRONG_INLINE Packet2Xs ptrue<Packet2Xs>(
const Packet2Xs& ) {
1431 return __riscv_vmv_v_x_i16m2(
static_cast<unsigned short>(0xffffu), unpacket_traits<Packet2Xs>::size);
1435EIGEN_STRONG_INLINE Packet2Xs pand<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1436 return __riscv_vand_vv_i16m2(a, b, unpacket_traits<Packet2Xs>::size);
1440EIGEN_STRONG_INLINE Packet2Xs por<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1441 return __riscv_vor_vv_i16m2(a, b, unpacket_traits<Packet2Xs>::size);
1445EIGEN_STRONG_INLINE Packet2Xs pxor<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1446 return __riscv_vxor_vv_i16m2(a, b, unpacket_traits<Packet2Xs>::size);
1450EIGEN_STRONG_INLINE Packet2Xs pandnot<Packet2Xs>(
const Packet2Xs& a,
const Packet2Xs& b) {
1452 return __riscv_vand_vv_i16m2(a, __riscv_vnot_v_i16m2(b, unpacket_traits<Packet2Xs>::size),
1453 unpacket_traits<Packet2Xs>::size);
1455 return __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vandn_vv_u16m2(
1456 __riscv_vreinterpret_v_i16m2_u16m2(a), __riscv_vreinterpret_v_i16m2_u16m2(b), unpacket_traits<Packet2Xs>::size));
1461EIGEN_STRONG_INLINE Packet2Xs pnot<Packet2Xs>(
const Packet2Xs& a) {
1462 return __riscv_vnot_v_i16m2(a, unpacket_traits<Packet2Xs>::size);
1466EIGEN_STRONG_INLINE Packet2Xs parithmetic_shift_right(
const Packet2Xs& a) {
1467 return __riscv_vsra_vx_i16m2(a, N, unpacket_traits<Packet2Xs>::size);
1471EIGEN_STRONG_INLINE Packet2Xs plogical_shift_right(
const Packet2Xs& a) {
1472 return __riscv_vreinterpret_i16m2(
1473 __riscv_vsrl_vx_u16m2(__riscv_vreinterpret_u16m2(a), N, unpacket_traits<Packet2Xs>::size));
1477EIGEN_STRONG_INLINE Packet2Xs plogical_shift_left(
const Packet2Xs& a) {
1478 return __riscv_vsll_vx_i16m2(a, N, unpacket_traits<Packet2Xs>::size);
1482EIGEN_STRONG_INLINE Packet2Xs pload<Packet2Xs>(
const numext::int16_t* from) {
1483 EIGEN_DEBUG_ALIGNED_LOAD
return __riscv_vle16_v_i16m2(from, unpacket_traits<Packet2Xs>::size);
1487EIGEN_STRONG_INLINE Packet2Xs ploadu<Packet2Xs>(
const numext::int16_t* from) {
1488 EIGEN_DEBUG_UNALIGNED_LOAD
return __riscv_vle16_v_i16m2(from, unpacket_traits<Packet2Xs>::size);
1492EIGEN_STRONG_INLINE Packet2Xs ploaddup<Packet2Xs>(
const numext::int16_t* from) {
1493 Packet2Xu data = __riscv_vlmul_trunc_v_u32m4_u32m2(__riscv_vwcvtu_x_x_v_u32m4(
1494 __riscv_vreinterpret_v_i16m2_u16m2(__riscv_vle16_v_i16m2(from, unpacket_traits<Packet2Xs>::size / 2)),
1495 unpacket_traits<Packet2Xs>::size / 2));
1496 return __riscv_vreinterpret_v_u32m2_i16m2(__riscv_vadd_vv_u32m2(
1497 __riscv_vsll_vx_u32m2(data, 16, unpacket_traits<Packet2Xi>::size), data, unpacket_traits<Packet2Xi>::size));
1501EIGEN_STRONG_INLINE Packet2Xs ploadquad<Packet2Xs>(
const numext::int16_t* from) {
1503 __riscv_vsrl_vx_u16m2(__riscv_vid_v_u16m2(unpacket_traits<Packet2Xs>::size), 2, unpacket_traits<Packet2Xs>::size);
1504 return __riscv_vrgather_vv_i16m2(pload<Packet2Xs>(from), idx, unpacket_traits<Packet2Xs>::size);
1508EIGEN_STRONG_INLINE
void pstore<numext::int16_t>(numext::int16_t* to,
const Packet2Xs& from) {
1509 EIGEN_DEBUG_ALIGNED_STORE __riscv_vse16_v_i16m2(to, from, unpacket_traits<Packet2Xs>::size);
1513EIGEN_STRONG_INLINE
void pstoreu<numext::int16_t>(numext::int16_t* to,
const Packet2Xs& from) {
1514 EIGEN_DEBUG_UNALIGNED_STORE __riscv_vse16_v_i16m2(to, from, unpacket_traits<Packet2Xs>::size);
1518EIGEN_DEVICE_FUNC
inline Packet2Xs pgather<numext::int16_t, Packet2Xs>(
const numext::int16_t* from, Index stride) {
1519 return __riscv_vlse16_v_i16m2(from, stride *
sizeof(numext::int16_t), unpacket_traits<Packet2Xs>::size);
1523EIGEN_DEVICE_FUNC
inline void pscatter<numext::int16_t, Packet2Xs>(numext::int16_t* to,
const Packet2Xs& from,
1525 __riscv_vsse16(to, stride *
sizeof(numext::int16_t), from, unpacket_traits<Packet2Xs>::size);
1529EIGEN_STRONG_INLINE numext::int16_t pfirst<Packet2Xs>(
const Packet2Xs& a) {
1530 return __riscv_vmv_x_s_i16m2_i16(a);
1534EIGEN_STRONG_INLINE Packet2Xs preverse(
const Packet2Xs& a) {
1535 Packet2Xsu idx = __riscv_vrsub_vx_u16m2(__riscv_vid_v_u16m2(unpacket_traits<Packet2Xs>::size),
1536 unpacket_traits<Packet2Xs>::size - 1, unpacket_traits<Packet2Xs>::size);
1537 return __riscv_vrgather_vv_i16m2(a, idx, unpacket_traits<Packet2Xs>::size);
1541EIGEN_STRONG_INLINE Packet2Xs pabs(
const Packet2Xs& a) {
1542 Packet2Xs mask = __riscv_vsra_vx_i16m2(a, 15, unpacket_traits<Packet2Xs>::size);
1543 return __riscv_vsub_vv_i16m2(__riscv_vxor_vv_i16m2(a, mask, unpacket_traits<Packet2Xs>::size), mask,
1544 unpacket_traits<Packet2Xs>::size);
1548EIGEN_STRONG_INLINE numext::int16_t predux<Packet2Xs>(
const Packet2Xs& a) {
1549 return __riscv_vmv_x(__riscv_vredsum_vs_i16m2_i16m1(a, __riscv_vmv_v_x_i16m1(0, unpacket_traits<Packet2Xs>::size / 2),
1550 unpacket_traits<Packet2Xs>::size));
1554EIGEN_STRONG_INLINE
bool predux_all(
const Packet2Xs& a) {
1555 const PacketMask8 mask = __riscv_vmseq_vx_i16m2_b8(a, 0, unpacket_traits<Packet2Xs>::size);
1556 return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet2Xs>::size) == 0;
1560EIGEN_STRONG_INLINE numext::int16_t predux_mul<Packet2Xs>(
const Packet2Xs& a) {
1561 return predux_mul<Packet1Xs>(__riscv_vmul_vv_i16m1(__riscv_vget_v_i16m2_i16m1(a, 0), __riscv_vget_v_i16m2_i16m1(a, 1),
1562 unpacket_traits<Packet1Xs>::size));
1566EIGEN_STRONG_INLINE numext::int16_t predux_min<Packet2Xs>(
const Packet2Xs& a) {
1567 return __riscv_vmv_x(__riscv_vredmin_vs_i16m2_i16m1(
1568 a, __riscv_vmv_v_x_i16m1((std::numeric_limits<numext::int16_t>::max)(), unpacket_traits<Packet2Xs>::size / 2),
1569 unpacket_traits<Packet2Xs>::size));
1573EIGEN_STRONG_INLINE numext::int16_t predux_max<Packet2Xs>(
const Packet2Xs& a) {
1574 return __riscv_vmv_x(__riscv_vredmax_vs_i16m2_i16m1(
1575 a, __riscv_vmv_v_x_i16m1((std::numeric_limits<numext::int16_t>::min)(), unpacket_traits<Packet2Xs>::size / 2),
1576 unpacket_traits<Packet2Xs>::size));
1580EIGEN_DEVICE_FUNC
inline void ptranspose(PacketBlock<Packet2Xs, N>& kernel) {
1581 numext::int16_t buffer[unpacket_traits<Packet2Xs>::size * N] = {0};
1584 for (i = 0; i < N; i++) {
1585 __riscv_vsse16(&buffer[i], N *
sizeof(numext::int16_t), kernel.packet[i], unpacket_traits<Packet2Xs>::size);
1587 for (i = 0; i < N; i++) {
1589 __riscv_vle16_v_i16m2(&buffer[i * unpacket_traits<Packet2Xs>::size], unpacket_traits<Packet2Xs>::size);
1593template <
typename Packet = Packet2Xs>
1595 std::enable_if_t<std::is_same<Packet, Packet2Xs>::value && (unpacket_traits<Packet2Xs>::size % 8) == 0, Packet1Xs>
1596 predux_half(
const Packet2Xs& a) {
1597 return __riscv_vadd_vv_i16m1(__riscv_vget_v_i16m2_i16m1(a, 0), __riscv_vget_v_i16m2_i16m1(a, 1),
1598 unpacket_traits<Packet1Xs>::size);