Eigen  5.0.1-dev+master
 
Loading...
Searching...
No Matches
PacketMath2.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2024 Kseniya Zaytseva <kseniya.zaytseva@syntacore.com>
5// Copyright (C) 2025 Chip Kerchner <ckerchner@tenstorrent.com>
6//
7// This Source Code Form is subject to the terms of the Mozilla
8// Public License v. 2.0. If a copy of the MPL was not distributed
9// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10// SPDX-License-Identifier: MPL-2.0
11
12#ifndef EIGEN_PACKET2_MATH_RVV10_H
13#define EIGEN_PACKET2_MATH_RVV10_H
14
15// IWYU pragma: private
16#include "../../InternalHeaderCheck.h"
17
18namespace Eigen {
19namespace internal {
20
21/********************************* Packet2Xi ************************************/
22
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));
25}
26
27template <>
28EIGEN_STRONG_INLINE Packet2Xi pset1<Packet2Xi>(const numext::int32_t& from) {
29 return __riscv_vmv_v_x_i32m2(from, unpacket_traits<Packet2Xi>::size);
30}
31
32template <>
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);
36}
37
38template <>
39EIGEN_STRONG_INLINE Packet2Xi pzero<Packet2Xi>(const Packet2Xi& /*a*/) {
40 return __riscv_vmv_v_x_i32m2(0, unpacket_traits<Packet2Xi>::size);
41}
42
43template <>
44EIGEN_STRONG_INLINE Packet2Xi padd<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
45 return __riscv_vadd_vv_i32m2(a, b, unpacket_traits<Packet2Xi>::size);
46}
47
48template <>
49EIGEN_STRONG_INLINE Packet2Xi psub<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
50 return __riscv_vsub(a, b, unpacket_traits<Packet2Xi>::size);
51}
52
53template <>
54EIGEN_STRONG_INLINE Packet2Xi pnegate(const Packet2Xi& a) {
55 return __riscv_vneg(a, unpacket_traits<Packet2Xi>::size);
56}
57
58template <>
59EIGEN_STRONG_INLINE Packet2Xi pmul<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
60 return __riscv_vmul(a, b, unpacket_traits<Packet2Xi>::size);
61}
62
63template <>
64EIGEN_STRONG_INLINE Packet2Xi pdiv<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
65 return __riscv_vdiv(a, b, unpacket_traits<Packet2Xi>::size);
66}
67
68template <>
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);
71}
72
73template <>
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);
76}
77
78template <>
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);
81}
82
83template <>
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);
86}
87
88template <>
89EIGEN_STRONG_INLINE Packet2Xi pmin<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
90 return __riscv_vmin(a, b, unpacket_traits<Packet2Xi>::size);
91}
92
93template <>
94EIGEN_STRONG_INLINE Packet2Xi pmax<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
95 return __riscv_vmax(a, b, unpacket_traits<Packet2Xi>::size);
96}
97
98template <>
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);
102}
103
104template <>
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);
108}
109
110template <>
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);
114}
115
116template <>
117EIGEN_STRONG_INLINE Packet2Xi ptrue<Packet2Xi>(const Packet2Xi& /*a*/) {
118 return __riscv_vmv_v_x_i32m2(0xffffffffu, unpacket_traits<Packet2Xi>::size);
119}
120
121template <>
122EIGEN_STRONG_INLINE Packet2Xi pand<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
123 return __riscv_vand_vv_i32m2(a, b, unpacket_traits<Packet2Xi>::size);
124}
125
126template <>
127EIGEN_STRONG_INLINE Packet2Xi por<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
128 return __riscv_vor_vv_i32m2(a, b, unpacket_traits<Packet2Xi>::size);
129}
130
131template <>
132EIGEN_STRONG_INLINE Packet2Xi pxor<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
133 return __riscv_vxor_vv_i32m2(a, b, unpacket_traits<Packet2Xi>::size);
134}
135
136template <>
137EIGEN_STRONG_INLINE Packet2Xi pandnot<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
138#ifndef __riscv_zvbb
139 return __riscv_vand_vv_i32m2(a, __riscv_vnot_v_i32m2(b, unpacket_traits<Packet2Xi>::size),
140 unpacket_traits<Packet2Xi>::size);
141#else
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));
144#endif
145}
146
147template <>
148EIGEN_STRONG_INLINE Packet2Xi pnot<Packet2Xi>(const Packet2Xi& a) {
149 return __riscv_vnot_v_i32m2(a, unpacket_traits<Packet2Xi>::size);
150}
151
152template <int N>
153EIGEN_STRONG_INLINE Packet2Xi parithmetic_shift_right(const Packet2Xi& a) {
154 return __riscv_vsra_vx_i32m2(a, N, unpacket_traits<Packet2Xi>::size);
155}
156
157template <int N>
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));
161}
162
163template <int N>
164EIGEN_STRONG_INLINE Packet2Xi plogical_shift_left(const Packet2Xi& a) {
165 return __riscv_vsll_vx_i32m2(a, N, unpacket_traits<Packet2Xi>::size);
166}
167
168template <>
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);
171}
172
173template <>
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);
176}
177
178template <>
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));
185}
186
187template <>
188EIGEN_STRONG_INLINE Packet2Xi ploadquad<Packet2Xi>(const numext::int32_t* from) {
189 Packet2Xu idx =
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);
192}
193
194template <>
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);
197}
198
199template <>
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);
202}
203
204template <>
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);
207}
208
209template <>
210EIGEN_DEVICE_FUNC inline void pscatter<numext::int32_t, Packet2Xi>(numext::int32_t* to, const Packet2Xi& from,
211 Index stride) {
212 __riscv_vsse32(to, stride * sizeof(numext::int32_t), from, unpacket_traits<Packet2Xi>::size);
213}
214
215template <>
216EIGEN_STRONG_INLINE numext::int32_t pfirst<Packet2Xi>(const Packet2Xi& a) {
217 return __riscv_vmv_x_s_i32m2_i32(a);
218}
219
220template <>
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);
225}
226
227template <>
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);
232}
233
234template <>
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));
238}
239
240template <>
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;
244}
245
246template <>
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));
250}
251
252template <>
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));
257}
258
259template <>
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));
264}
265
266template <int N>
267EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2Xi, N>& kernel) {
268 numext::int32_t buffer[unpacket_traits<Packet2Xi>::size * N] = {0};
269 int i = 0;
270
271 for (i = 0; i < N; i++) {
272 __riscv_vsse32(&buffer[i], N * sizeof(numext::int32_t), kernel.packet[i], unpacket_traits<Packet2Xi>::size);
273 }
274 for (i = 0; i < N; i++) {
275 kernel.packet[i] =
276 __riscv_vle32_v_i32m2(&buffer[i * unpacket_traits<Packet2Xi>::size], unpacket_traits<Packet2Xi>::size);
277 }
278}
279
280template <typename Packet = Packet2Xi>
281EIGEN_STRONG_INLINE
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);
286}
287
288/********************************* Packet2Xf ************************************/
289
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));
292}
293
294template <>
295EIGEN_STRONG_INLINE Packet2Xf ptrue<Packet2Xf>(const Packet2Xf& /*a*/) {
296 Packet2Xf r = __riscv_vreinterpret_f32m2(__riscv_vmv_v_x_u32m2(0xffffffffu, unpacket_traits<Packet2Xf>::size));
297 EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
298 return r;
299}
300
301template <>
302EIGEN_STRONG_INLINE Packet2Xf pzero<Packet2Xf>(const Packet2Xf& /*a*/) {
303 return __riscv_vfmv_v_f_f32m2(0.0f, unpacket_traits<Packet2Xf>::size);
304}
305
306template <>
307EIGEN_STRONG_INLINE Packet2Xf pabs(const Packet2Xf& a) {
308 return __riscv_vfabs_v_f32m2(a, unpacket_traits<Packet2Xf>::size);
309}
310
311template <>
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);
315}
316
317template <>
318EIGEN_STRONG_INLINE Packet2Xf pset1<Packet2Xf>(const float& from) {
319 return __riscv_vfmv_v_f_f32m2(from, unpacket_traits<Packet2Xf>::size);
320}
321
322template <>
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));
325}
326
327template <>
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);
333}
334
335template <>
336EIGEN_STRONG_INLINE void pbroadcast4<Packet2Xf>(const float* a, Packet2Xf& a0, Packet2Xf& a1, Packet2Xf& a2,
337 Packet2Xf& a3) {
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);
343}
344
345template <>
346EIGEN_STRONG_INLINE Packet2Xf padd<Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
347 return __riscv_vfadd_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
348}
349
350template <>
351EIGEN_STRONG_INLINE Packet2Xf psub<Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
352 return __riscv_vfsub_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
353}
354
355template <>
356EIGEN_STRONG_INLINE Packet2Xf pnegate(const Packet2Xf& a) {
357 return __riscv_vfneg_v_f32m2(a, unpacket_traits<Packet2Xf>::size);
358}
359
360template <>
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));
364}
365
366template <>
367EIGEN_STRONG_INLINE Packet2Xf pmul<Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
368 return __riscv_vfmul_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
369}
370
371template <>
372EIGEN_STRONG_INLINE Packet2Xf pdiv<Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
373 return __riscv_vfdiv_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
374}
375
376template <>
377struct is_fused_madd<Packet2Xf> : true_type {};
378template <>
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);
381}
382
383template <>
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);
386}
387
388template <>
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);
391}
392
393template <>
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);
396}
397
398template <>
399struct pminmax_propagates_nan<Packet2Xf> : bool_constant<true> {};
400
401template <>
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);
407
408 return __riscv_vfmin_vv_f32m2_tumu(mask, nans, a, b, unpacket_traits<Packet2Xf>::size);
409}
410
411template <>
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);
414}
415
416template <>
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);
422
423 return __riscv_vfmax_vv_f32m2_tumu(mask, nans, a, b, unpacket_traits<Packet2Xf>::size);
424}
425
426template <>
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);
429}
430
431template <>
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);
435}
436
437template <>
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);
441}
442
443template <>
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);
447}
448
449template <>
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);
453}
454
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);
457}
458
459EIGEN_STRONG_INLINE Packet2Xf pselect(const Packet2Xf& mask, const Packet2Xf& a, const Packet2Xf& b) {
460 PacketMask16 mask2 =
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);
463}
464
465// Logical Operations are not supported for float, so reinterpret casts
466template <>
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));
470}
471
472template <>
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));
476}
477
478template <>
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));
482}
483
484template <>
485EIGEN_STRONG_INLINE Packet2Xf pandnot<Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
486#ifndef __riscv_zvbb
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));
491#else
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));
494#endif
495}
496
497template <>
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));
501}
502
503template <>
504EIGEN_STRONG_INLINE Packet2Xf pload<Packet2Xf>(const float* from) {
505 EIGEN_DEBUG_ALIGNED_LOAD return __riscv_vle32_v_f32m2(from, unpacket_traits<Packet2Xf>::size);
506}
507
508template <>
509EIGEN_STRONG_INLINE Packet2Xf ploadu<Packet2Xf>(const float* from) {
510 EIGEN_DEBUG_UNALIGNED_LOAD return __riscv_vle32_v_f32m2(from, unpacket_traits<Packet2Xf>::size);
511}
512
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));
517}
518
519template <>
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));
526}
527
528template <>
529EIGEN_STRONG_INLINE Packet2Xf ploadquad<Packet2Xf>(const float* from) {
530 Packet2Xu idx =
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);
533}
534
535template <>
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);
538}
539
540template <>
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);
543}
544
545template <>
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);
548}
549
550template <>
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);
553}
554
555template <>
556EIGEN_STRONG_INLINE float pfirst<Packet2Xf>(const Packet2Xf& a) {
557 return __riscv_vfmv_f_s_f32m2_f32(a);
558}
559
560template <>
561EIGEN_STRONG_INLINE Packet2Xf psqrt(const Packet2Xf& a) {
562 return __riscv_vfsqrt_v_f32m2(a, unpacket_traits<Packet2Xf>::size);
563}
564
565template <>
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);
569
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);
574
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);
578}
579
580template <>
581EIGEN_STRONG_INLINE Packet2Xf pfloor<Packet2Xf>(const Packet2Xf& a) {
582 Packet2Xf tmp = print<Packet2Xf>(a);
583 // If greater, subtract one.
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);
586}
587
588template <>
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);
593}
594
595template <>
596EIGEN_STRONG_INLINE Packet2Xf pfrexp<Packet2Xf>(const Packet2Xf& a, Packet2Xf& exponent) {
597 return pfrexp_generic(a, exponent);
598}
599
600template <>
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));
604}
605
606template <>
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;
611}
612
613template <>
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;
617}
618
619template <>
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));
623}
624
625template <>
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));
629}
630
631// Reusing the first lane is exact for an idempotent reduction and avoids a NaN seed that becomes poison under
632// finite fast-math.
633template <>
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));
637}
638
639template <>
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));
643}
644
645template <>
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));
649}
650
651template <int N>
652EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2Xf, N>& kernel) {
653 float buffer[unpacket_traits<Packet2Xf>::size * N];
654 int i = 0;
655
656 for (i = 0; i < N; i++) {
657 __riscv_vsse32(&buffer[i], N * sizeof(float), kernel.packet[i], unpacket_traits<Packet2Xf>::size);
658 }
659
660 for (i = 0; i < N; i++) {
661 kernel.packet[i] =
662 __riscv_vle32_v_f32m2(&buffer[i * unpacket_traits<Packet2Xf>::size], unpacket_traits<Packet2Xf>::size);
663 }
664}
665
666template <>
667EIGEN_STRONG_INLINE Packet2Xf pldexp<Packet2Xf>(const Packet2Xf& a, const Packet2Xf& exponent) {
668 return pldexp_generic(a, exponent);
669}
670
671template <typename Packet = Packet2Xf>
672EIGEN_STRONG_INLINE
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);
677}
678
679/********************************* Packet2Xl ************************************/
680
681template <>
682EIGEN_STRONG_INLINE Packet2Xl pset1<Packet2Xl>(const numext::int64_t& from) {
683 return __riscv_vmv_v_x_i64m2(from, unpacket_traits<Packet2Xl>::size);
684}
685
686template <>
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);
690}
691
692template <>
693EIGEN_STRONG_INLINE Packet2Xl pzero<Packet2Xl>(const Packet2Xl& /*a*/) {
694 return __riscv_vmv_v_x_i64m2(0, unpacket_traits<Packet2Xl>::size);
695}
696
697template <>
698EIGEN_STRONG_INLINE Packet2Xl padd<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
699 return __riscv_vadd_vv_i64m2(a, b, unpacket_traits<Packet2Xl>::size);
700}
701
702template <>
703EIGEN_STRONG_INLINE Packet2Xl psub<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
704 return __riscv_vsub(a, b, unpacket_traits<Packet2Xl>::size);
705}
706
707template <>
708EIGEN_STRONG_INLINE Packet2Xl pnegate(const Packet2Xl& a) {
709 return __riscv_vneg(a, unpacket_traits<Packet2Xl>::size);
710}
711
712template <>
713EIGEN_STRONG_INLINE Packet2Xl pmul<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
714 return __riscv_vmul(a, b, unpacket_traits<Packet2Xl>::size);
715}
716
717template <>
718EIGEN_STRONG_INLINE Packet2Xl pdiv<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
719 return __riscv_vdiv(a, b, unpacket_traits<Packet2Xl>::size);
720}
721
722template <>
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);
725}
726
727template <>
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);
730}
731
732template <>
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);
735}
736
737template <>
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);
740}
741
742template <>
743EIGEN_STRONG_INLINE Packet2Xl pmin<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
744 return __riscv_vmin(a, b, unpacket_traits<Packet2Xl>::size);
745}
746
747template <>
748EIGEN_STRONG_INLINE Packet2Xl pmax<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
749 return __riscv_vmax(a, b, unpacket_traits<Packet2Xl>::size);
750}
751
752template <>
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);
756}
757
758template <>
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);
762}
763
764template <>
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);
768}
769
770template <>
771EIGEN_STRONG_INLINE Packet2Xl ptrue<Packet2Xl>(const Packet2Xl& /*a*/) {
772 return __riscv_vmv_v_x_i64m2(0xffffffffffffffffu, unpacket_traits<Packet2Xl>::size);
773}
774
775template <>
776EIGEN_STRONG_INLINE Packet2Xl pand<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
777 return __riscv_vand_vv_i64m2(a, b, unpacket_traits<Packet2Xl>::size);
778}
779
780template <>
781EIGEN_STRONG_INLINE Packet2Xl por<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
782 return __riscv_vor_vv_i64m2(a, b, unpacket_traits<Packet2Xl>::size);
783}
784
785template <>
786EIGEN_STRONG_INLINE Packet2Xl pnot<Packet2Xl>(const Packet2Xl& a) {
787 return __riscv_vnot_v_i64m2(a, unpacket_traits<Packet2Xl>::size);
788}
789
790template <>
791EIGEN_STRONG_INLINE Packet2Xl pxor<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
792 return __riscv_vxor_vv_i64m2(a, b, unpacket_traits<Packet2Xl>::size);
793}
794
795template <>
796EIGEN_STRONG_INLINE Packet2Xl pandnot<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
797#ifndef __riscv_zvbb
798 return __riscv_vand_vv_i64m2(a, __riscv_vnot_v_i64m2(b, unpacket_traits<Packet2Xl>::size),
799 unpacket_traits<Packet2Xl>::size);
800#else
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));
803#endif
804}
805
806template <int N>
807EIGEN_STRONG_INLINE Packet2Xl parithmetic_shift_right(const Packet2Xl& a) {
808 return __riscv_vsra_vx_i64m2(a, N, unpacket_traits<Packet2Xl>::size);
809}
810
811template <int N>
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));
815}
816
817template <int N>
818EIGEN_STRONG_INLINE Packet2Xl plogical_shift_left(const Packet2Xl& a) {
819 return __riscv_vsll_vx_i64m2(a, N, unpacket_traits<Packet2Xl>::size);
820}
821
822template <>
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);
825}
826
827template <>
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);
830}
831
832template <>
833EIGEN_STRONG_INLINE Packet2Xl ploaddup<Packet2Xl>(const numext::int64_t* from) {
834 Packet2Xul idx =
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);
838}
839
840template <>
841EIGEN_STRONG_INLINE Packet2Xl ploadquad<Packet2Xl>(const numext::int64_t* from) {
842 Packet2Xul idx =
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);
845}
846
847template <>
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);
850}
851
852template <>
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);
855}
856
857template <>
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);
860}
861
862template <>
863EIGEN_DEVICE_FUNC inline void pscatter<numext::int64_t, Packet2Xl>(numext::int64_t* to, const Packet2Xl& from,
864 Index stride) {
865 __riscv_vsse64(to, stride * sizeof(numext::int64_t), from, unpacket_traits<Packet2Xl>::size);
866}
867
868template <>
869EIGEN_STRONG_INLINE numext::int64_t pfirst<Packet2Xl>(const Packet2Xl& a) {
870 return __riscv_vmv_x_s_i64m2_i64(a);
871}
872
873template <>
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);
878}
879
880template <>
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);
885}
886
887template <>
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));
891}
892
893template <>
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;
897}
898
899template <>
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));
903}
904
905template <>
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));
910}
911
912template <>
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));
917}
918
919template <int N>
920EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2Xl, N>& kernel) {
921 numext::int64_t buffer[unpacket_traits<Packet2Xl>::size * N] = {0};
922 int i = 0;
923
924 for (i = 0; i < N; i++) {
925 __riscv_vsse64(&buffer[i], N * sizeof(numext::int64_t), kernel.packet[i], unpacket_traits<Packet2Xl>::size);
926 }
927 for (i = 0; i < N; i++) {
928 kernel.packet[i] =
929 __riscv_vle64_v_i64m2(&buffer[i * unpacket_traits<Packet2Xl>::size], unpacket_traits<Packet2Xl>::size);
930 }
931}
932
933template <typename Packet = Packet2Xl>
934EIGEN_STRONG_INLINE
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);
939}
940
941/********************************* Packet2Xd ************************************/
942
943template <>
944EIGEN_STRONG_INLINE Packet2Xd ptrue<Packet2Xd>(const Packet2Xd& /*a*/) {
945 Packet2Xd r =
946 __riscv_vreinterpret_f64m2(__riscv_vmv_v_x_u64m2(0xffffffffffffffffu, unpacket_traits<Packet2Xd>::size));
947 EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
948 return r;
949}
950
951template <>
952EIGEN_STRONG_INLINE Packet2Xd pzero<Packet2Xd>(const Packet2Xd& /*a*/) {
953 return __riscv_vfmv_v_f_f64m2(0.0, unpacket_traits<Packet2Xd>::size);
954}
955
956template <>
957EIGEN_STRONG_INLINE Packet2Xd pabs(const Packet2Xd& a) {
958 return __riscv_vfabs_v_f64m2(a, unpacket_traits<Packet2Xd>::size);
959}
960
961template <>
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);
965}
966
967template <>
968EIGEN_STRONG_INLINE Packet2Xd pset1<Packet2Xd>(const double& from) {
969 return __riscv_vfmv_v_f_f64m2(from, unpacket_traits<Packet2Xd>::size);
970}
971
972template <>
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));
975}
976
977template <>
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);
983}
984
985template <>
986EIGEN_STRONG_INLINE void pbroadcast4<Packet2Xd>(const double* a, Packet2Xd& a0, Packet2Xd& a1, Packet2Xd& a2,
987 Packet2Xd& a3) {
988 Packet2Xd aa;
989 EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
990 aa = __riscv_vlmul_ext_f64m2(__riscv_vle64_v_f64m1(a, 4));
991 } else {
992 aa = __riscv_vle64_v_f64m2(a, 4);
993 }
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);
998}
999
1000template <>
1001EIGEN_STRONG_INLINE Packet2Xd padd<Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
1002 return __riscv_vfadd_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
1003}
1004
1005template <>
1006EIGEN_STRONG_INLINE Packet2Xd psub<Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
1007 return __riscv_vfsub_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
1008}
1009
1010template <>
1011EIGEN_STRONG_INLINE Packet2Xd pnegate(const Packet2Xd& a) {
1012 return __riscv_vfneg_v_f64m2(a, unpacket_traits<Packet2Xd>::size);
1013}
1014
1015template <>
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));
1019}
1020
1021template <>
1022EIGEN_STRONG_INLINE Packet2Xd pmul<Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
1023 return __riscv_vfmul_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
1024}
1025
1026template <>
1027EIGEN_STRONG_INLINE Packet2Xd pdiv<Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
1028 return __riscv_vfdiv_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
1029}
1030
1031template <>
1032struct is_fused_madd<Packet2Xd> : true_type {};
1033template <>
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);
1036}
1037
1038template <>
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);
1041}
1042
1043template <>
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);
1046}
1047
1048template <>
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);
1051}
1052
1053template <>
1054struct pminmax_propagates_nan<Packet2Xd> : bool_constant<true> {};
1055
1056template <>
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);
1062
1063 return __riscv_vfmin_vv_f64m2_tumu(mask, nans, a, b, unpacket_traits<Packet2Xd>::size);
1064}
1065
1066template <>
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);
1069}
1070
1071template <>
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);
1077
1078 return __riscv_vfmax_vv_f64m2_tumu(mask, nans, a, b, unpacket_traits<Packet2Xd>::size);
1079}
1080
1081template <>
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);
1084}
1085
1086template <>
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);
1090}
1091
1092template <>
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);
1096}
1097
1098template <>
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);
1102}
1103
1104template <>
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);
1108}
1109
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);
1112}
1113
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);
1118}
1119
1120// Logical Operations are not supported for double, so reinterpret casts
1121template <>
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));
1125}
1126
1127template <>
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));
1131}
1132
1133template <>
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));
1137}
1138
1139template <>
1140EIGEN_STRONG_INLINE Packet2Xd pandnot<Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
1141#ifndef __riscv_zvbb
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));
1146#else
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));
1149#endif
1150}
1151
1152template <>
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));
1156}
1157
1158template <>
1159EIGEN_STRONG_INLINE Packet2Xd pload<Packet2Xd>(const double* from) {
1160 EIGEN_DEBUG_ALIGNED_LOAD return __riscv_vle64_v_f64m2(from, unpacket_traits<Packet2Xd>::size);
1161}
1162
1163template <>
1164EIGEN_STRONG_INLINE Packet2Xd ploadu<Packet2Xd>(const double* from) {
1165 EIGEN_DEBUG_UNALIGNED_LOAD return __riscv_vle64_v_f64m2(from, unpacket_traits<Packet2Xd>::size);
1166}
1167
1168EIGEN_STRONG_INLINE Packet4Xd pdup(const Packet2Xd& a) {
1169 Packet4Xul idx =
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);
1172}
1173
1174template <>
1175EIGEN_STRONG_INLINE Packet2Xd ploaddup<Packet2Xd>(const double* from) {
1176 Packet2Xul idx =
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);
1180}
1181
1182template <>
1183EIGEN_STRONG_INLINE Packet2Xd ploadquad<Packet2Xd>(const double* from) {
1184 Packet2Xul idx =
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);
1188}
1189
1190template <>
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);
1193}
1194
1195template <>
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);
1198}
1199
1200template <>
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);
1203}
1204
1205template <>
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);
1208}
1209
1210template <>
1211EIGEN_STRONG_INLINE double pfirst<Packet2Xd>(const Packet2Xd& a) {
1212 return __riscv_vfmv_f_s_f64m2_f64(a);
1213}
1214
1215template <>
1216EIGEN_STRONG_INLINE Packet2Xd psqrt(const Packet2Xd& a) {
1217 return __riscv_vfsqrt_v_f64m2(a, unpacket_traits<Packet2Xd>::size);
1218}
1219
1220template <>
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);
1224
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);
1229
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);
1233}
1234
1235template <>
1236EIGEN_STRONG_INLINE Packet2Xd pfloor<Packet2Xd>(const Packet2Xd& a) {
1237 Packet2Xd tmp = print<Packet2Xd>(a);
1238 // If greater, subtract one.
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);
1241}
1242
1243template <>
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);
1248}
1249
1250template <>
1251EIGEN_STRONG_INLINE Packet2Xd pfrexp<Packet2Xd>(const Packet2Xd& a, Packet2Xd& exponent) {
1252 return pfrexp_generic(a, exponent);
1253}
1254
1255template <>
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));
1259}
1260
1261template <>
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;
1266}
1267
1268template <>
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;
1272}
1273
1274template <>
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));
1278}
1279
1280template <>
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));
1284}
1285
1286template <>
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));
1290}
1291
1292template <>
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));
1296}
1297
1298#if __riscv_v_min_vlen >= 256
1299template <>
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));
1303}
1304#endif
1305
1306template <int N>
1307EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2Xd, N>& kernel) {
1308 double buffer[unpacket_traits<Packet2Xd>::size * N];
1309 int i = 0;
1310
1311 for (i = 0; i < N; i++) {
1312 __riscv_vsse64(&buffer[i], N * sizeof(double), kernel.packet[i], unpacket_traits<Packet2Xd>::size);
1313 }
1314
1315 for (i = 0; i < N; i++) {
1316 kernel.packet[i] =
1317 __riscv_vle64_v_f64m2(&buffer[i * unpacket_traits<Packet2Xd>::size], unpacket_traits<Packet2Xd>::size);
1318 }
1319}
1320
1321template <>
1322EIGEN_STRONG_INLINE Packet2Xd pldexp<Packet2Xd>(const Packet2Xd& a, const Packet2Xd& exponent) {
1323 return pldexp_generic(a, exponent);
1324}
1325
1326template <typename Packet = Packet2Xd>
1327EIGEN_STRONG_INLINE
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);
1332}
1333
1334/********************************* Packet2Xs ************************************/
1335
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));
1338}
1339
1340template <>
1341EIGEN_STRONG_INLINE Packet2Xs pset1<Packet2Xs>(const numext::int16_t& from) {
1342 return __riscv_vmv_v_x_i16m2(from, unpacket_traits<Packet2Xs>::size);
1343}
1344
1345template <>
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);
1349}
1350
1351template <>
1352EIGEN_STRONG_INLINE Packet2Xs pzero<Packet2Xs>(const Packet2Xs& /*a*/) {
1353 return __riscv_vmv_v_x_i16m2(0, unpacket_traits<Packet2Xs>::size);
1354}
1355
1356template <>
1357EIGEN_STRONG_INLINE Packet2Xs padd<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
1358 return __riscv_vadd_vv_i16m2(a, b, unpacket_traits<Packet2Xs>::size);
1359}
1360
1361template <>
1362EIGEN_STRONG_INLINE Packet2Xs psub<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
1363 return __riscv_vsub(a, b, unpacket_traits<Packet2Xs>::size);
1364}
1365
1366template <>
1367EIGEN_STRONG_INLINE Packet2Xs pnegate(const Packet2Xs& a) {
1368 return __riscv_vneg(a, unpacket_traits<Packet2Xs>::size);
1369}
1370
1371template <>
1372EIGEN_STRONG_INLINE Packet2Xs pmul<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
1373 return __riscv_vmul(a, b, unpacket_traits<Packet2Xs>::size);
1374}
1375
1376template <>
1377EIGEN_STRONG_INLINE Packet2Xs pdiv<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
1378 return __riscv_vdiv(a, b, unpacket_traits<Packet2Xs>::size);
1379}
1380
1381template <>
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);
1384}
1385
1386template <>
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);
1389}
1390
1391template <>
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);
1394}
1395
1396template <>
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);
1399}
1400
1401template <>
1402EIGEN_STRONG_INLINE Packet2Xs pmin<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
1403 return __riscv_vmin(a, b, unpacket_traits<Packet2Xs>::size);
1404}
1405
1406template <>
1407EIGEN_STRONG_INLINE Packet2Xs pmax<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
1408 return __riscv_vmax(a, b, unpacket_traits<Packet2Xs>::size);
1409}
1410
1411template <>
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);
1415}
1416
1417template <>
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);
1421}
1422
1423template <>
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);
1427}
1428
1429template <>
1430EIGEN_STRONG_INLINE Packet2Xs ptrue<Packet2Xs>(const Packet2Xs& /*a*/) {
1431 return __riscv_vmv_v_x_i16m2(static_cast<unsigned short>(0xffffu), unpacket_traits<Packet2Xs>::size);
1432}
1433
1434template <>
1435EIGEN_STRONG_INLINE Packet2Xs pand<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
1436 return __riscv_vand_vv_i16m2(a, b, unpacket_traits<Packet2Xs>::size);
1437}
1438
1439template <>
1440EIGEN_STRONG_INLINE Packet2Xs por<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
1441 return __riscv_vor_vv_i16m2(a, b, unpacket_traits<Packet2Xs>::size);
1442}
1443
1444template <>
1445EIGEN_STRONG_INLINE Packet2Xs pxor<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
1446 return __riscv_vxor_vv_i16m2(a, b, unpacket_traits<Packet2Xs>::size);
1447}
1448
1449template <>
1450EIGEN_STRONG_INLINE Packet2Xs pandnot<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
1451#ifndef __riscv_zvbb
1452 return __riscv_vand_vv_i16m2(a, __riscv_vnot_v_i16m2(b, unpacket_traits<Packet2Xs>::size),
1453 unpacket_traits<Packet2Xs>::size);
1454#else
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));
1457#endif
1458}
1459
1460template <>
1461EIGEN_STRONG_INLINE Packet2Xs pnot<Packet2Xs>(const Packet2Xs& a) {
1462 return __riscv_vnot_v_i16m2(a, unpacket_traits<Packet2Xs>::size);
1463}
1464
1465template <int N>
1466EIGEN_STRONG_INLINE Packet2Xs parithmetic_shift_right(const Packet2Xs& a) {
1467 return __riscv_vsra_vx_i16m2(a, N, unpacket_traits<Packet2Xs>::size);
1468}
1469
1470template <int N>
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));
1474}
1475
1476template <int N>
1477EIGEN_STRONG_INLINE Packet2Xs plogical_shift_left(const Packet2Xs& a) {
1478 return __riscv_vsll_vx_i16m2(a, N, unpacket_traits<Packet2Xs>::size);
1479}
1480
1481template <>
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);
1484}
1485
1486template <>
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);
1489}
1490
1491template <>
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));
1498}
1499
1500template <>
1501EIGEN_STRONG_INLINE Packet2Xs ploadquad<Packet2Xs>(const numext::int16_t* from) {
1502 Packet2Xsu idx =
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);
1505}
1506
1507template <>
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);
1510}
1511
1512template <>
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);
1515}
1516
1517template <>
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);
1520}
1521
1522template <>
1523EIGEN_DEVICE_FUNC inline void pscatter<numext::int16_t, Packet2Xs>(numext::int16_t* to, const Packet2Xs& from,
1524 Index stride) {
1525 __riscv_vsse16(to, stride * sizeof(numext::int16_t), from, unpacket_traits<Packet2Xs>::size);
1526}
1527
1528template <>
1529EIGEN_STRONG_INLINE numext::int16_t pfirst<Packet2Xs>(const Packet2Xs& a) {
1530 return __riscv_vmv_x_s_i16m2_i16(a);
1531}
1532
1533template <>
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);
1538}
1539
1540template <>
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);
1545}
1546
1547template <>
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));
1551}
1552
1553template <>
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;
1557}
1558
1559template <>
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));
1563}
1564
1565template <>
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));
1570}
1571
1572template <>
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));
1577}
1578
1579template <int N>
1580EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2Xs, N>& kernel) {
1581 numext::int16_t buffer[unpacket_traits<Packet2Xs>::size * N] = {0};
1582 int i = 0;
1583
1584 for (i = 0; i < N; i++) {
1585 __riscv_vsse16(&buffer[i], N * sizeof(numext::int16_t), kernel.packet[i], unpacket_traits<Packet2Xs>::size);
1586 }
1587 for (i = 0; i < N; i++) {
1588 kernel.packet[i] =
1589 __riscv_vle16_v_i16m2(&buffer[i * unpacket_traits<Packet2Xs>::size], unpacket_traits<Packet2Xs>::size);
1590 }
1591}
1592
1593template <typename Packet = Packet2Xs>
1594EIGEN_STRONG_INLINE
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);
1599}
1600
1601} // namespace internal
1602} // namespace Eigen
1603
1604#endif // EIGEN_PACKET2_MATH_RVV10_H