Eigen  5.0.1
 
Loading...
Searching...
No Matches
Complex2.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2026 Chip Kerchner <ckerchner@tenstorrent.com>
5//
6// This Source Code Form is subject to the terms of the Mozilla
7// Public License v. 2.0. If a copy of the MPL was not distributed
8// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9// SPDX-License-Identifier: MPL-2.0
10
11#ifndef EIGEN_COMPLEX2_RVV10_H
12#define EIGEN_COMPLEX2_RVV10_H
13
14// IWYU pragma: private
15#include "../../InternalHeaderCheck.h"
16
17namespace Eigen {
18
19namespace internal {
20
21/********************************* float32 ************************************/
22
23template <>
24EIGEN_STRONG_INLINE Packet4Xcf pcast<Packet4Xf, Packet4Xcf>(const Packet4Xf& a) {
25 return Packet4Xcf(a);
26}
27
28template <>
29EIGEN_STRONG_INLINE Packet4Xf pcast<Packet4Xcf, Packet4Xf>(const Packet4Xcf& a) {
30 return a.v;
31}
32
33EIGEN_STRONG_INLINE Packet4Xul __riscv_vreinterpret_v_f32m4_u64m4(const Packet4Xf& a) {
34 return __riscv_vreinterpret_v_u32m4_u64m4(__riscv_vreinterpret_v_f32m4_u32m4(a));
35}
36
37EIGEN_STRONG_INLINE Packet4Xl __riscv_vreinterpret_v_f32m4_i64m4(const Packet4Xf& a) {
38 return __riscv_vreinterpret_v_u64m4_i64m4(__riscv_vreinterpret_v_u32m4_u64m4(__riscv_vreinterpret_v_f32m4_u32m4(a)));
39}
40
41EIGEN_STRONG_INLINE Packet4Xf __riscv_vreinterpret_v_i64m4_f32m4(const Packet4Xl& a) {
42 return __riscv_vreinterpret_v_u32m4_f32m4(__riscv_vreinterpret_v_u64m4_u32m4(__riscv_vreinterpret_v_i64m4_u64m4(a)));
43}
44
45EIGEN_STRONG_INLINE Packet2Xd __riscv_vreinterpret_v_f32m2_f64m2(const Packet2Xf& a) {
46 return __riscv_vreinterpret_v_u64m2_f64m2(__riscv_vreinterpret_v_u32m2_u64m2(__riscv_vreinterpret_v_f32m2_u32m2(a)));
47}
48
49EIGEN_STRONG_INLINE Packet4Xf __riscv_vreinterpret_v_f64m4_f32m4(const Packet4Xd& a) {
50 return __riscv_vreinterpret_v_u32m4_f32m4(__riscv_vreinterpret_v_u64m4_u32m4(__riscv_vreinterpret_v_f64m4_u64m4(a)));
51}
52
53EIGEN_STRONG_INLINE void prealimag2(const Packet4Xcf& a, Packet4Xf& real, Packet4Xf& imag) {
54 const PacketMask8 mask =
55 __riscv_vreinterpret_v_i8m1_b8(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
56 Packet4Xu res = __riscv_vreinterpret_v_f32m4_u32m4(a.v);
57 real = __riscv_vreinterpret_v_u32m4_f32m4(
58 __riscv_vslide1up_vx_u32m4_tumu(mask, res, res, 0, unpacket_traits<Packet4Xi>::size));
59 imag = __riscv_vreinterpret_v_u32m4_f32m4(__riscv_vslide1down_vx_u32m4_tumu(
60 __riscv_vmnot_m_b8(mask, unpacket_traits<Packet1Xc>::size), res, res, 0, unpacket_traits<Packet4Xi>::size));
61}
62
63template <>
64EIGEN_STRONG_INLINE Packet4Xcf pset1<Packet4Xcf>(const std::complex<float>& from) {
65 const numext::int64_t from2 = numext::bit_cast<numext::int64_t>(from);
66 Packet4Xf res = __riscv_vreinterpret_v_i64m4_f32m4(pset1<Packet4Xl>(from2));
67 return Packet4Xcf(res);
68}
69
70template <>
71EIGEN_STRONG_INLINE Packet4Xcf padd<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
72 return Packet4Xcf(padd<Packet4Xf>(a.v, b.v));
73}
74
75template <>
76EIGEN_STRONG_INLINE Packet4Xcf psub<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
77 return Packet4Xcf(psub<Packet4Xf>(a.v, b.v));
78}
79
80template <>
81EIGEN_STRONG_INLINE Packet4Xcf pnegate(const Packet4Xcf& a) {
82 return Packet4Xcf(pnegate<Packet4Xf>(a.v));
83}
84
85template <>
86EIGEN_STRONG_INLINE Packet4Xcf pconj(const Packet4Xcf& a) {
87 return Packet4Xcf(__riscv_vreinterpret_v_u64m4_f32m4(__riscv_vxor_vx_u64m4(
88 __riscv_vreinterpret_v_f32m4_u64m4(a.v), 0x8000000000000000ull, unpacket_traits<Packet4Xl>::size)));
89}
90
91template <>
92EIGEN_STRONG_INLINE Packet4Xcf pcplxflip<Packet4Xcf>(const Packet4Xcf& a) {
93#ifndef __riscv_zvbb
94 Packet4Xu res = __riscv_vreinterpret_v_f32m4_u32m4(a.v);
95 const PacketMask8 mask =
96 __riscv_vreinterpret_v_i8m1_b8(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
97 Packet4Xu data = __riscv_vslide1down_vx_u32m4(res, 0, unpacket_traits<Packet4Xi>::size);
98 Packet4Xf res2 = __riscv_vreinterpret_v_u32m4_f32m4(
99 __riscv_vslide1up_vx_u32m4_tumu(mask, data, res, 0, unpacket_traits<Packet4Xi>::size));
100 return Packet4Xcf(res2);
101#else
102 Packet4Xf res = __riscv_vreinterpret_v_u64m4_f32m4(
103 __riscv_vror_vx_u64m4(__riscv_vreinterpret_v_f32m4_u64m4(a.v), 32, unpacket_traits<Packet4Xl>::size));
104 return Packet4Xcf(res);
105#endif
106}
107
108template <>
109EIGEN_STRONG_INLINE Packet4Xcf pmul<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
110 Packet4Xf real, imag;
111 prealimag2(a, real, imag);
112 return Packet4Xcf(pmadd<Packet4Xf>(imag, pcplxflip<Packet4Xcf>(pconj<Packet4Xcf>(b)).v, pmul<Packet4Xf>(real, b.v)));
113}
114
115template <>
116EIGEN_STRONG_INLINE Packet4Xcf pmadd<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b, const Packet4Xcf& c) {
117 Packet4Xf real, imag;
118 prealimag2(a, real, imag);
119 return Packet4Xcf(
120 pmadd<Packet4Xf>(imag, pcplxflip<Packet4Xcf>(pconj<Packet4Xcf>(b)).v, pmadd<Packet4Xf>(real, b.v, c.v)));
121}
122
123template <>
124EIGEN_STRONG_INLINE Packet4Xcf pmsub<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b, const Packet4Xcf& c) {
125 Packet4Xf real, imag;
126 prealimag2(a, real, imag);
127 return Packet4Xcf(
128 pmadd<Packet4Xf>(imag, pcplxflip<Packet4Xcf>(pconj<Packet4Xcf>(b)).v, pmsub<Packet4Xf>(real, b.v, c.v)));
129}
130
131template <>
132EIGEN_STRONG_INLINE Packet4Xcf pcmp_eq(const Packet4Xcf& a, const Packet4Xcf& b) {
133 Packet4Xi c = __riscv_vundefined_i32m4();
134 PacketMask8 mask = __riscv_vmfeq_vv_f32m4_b8(a.v, b.v, unpacket_traits<Packet4Xf>::size);
135 Packet4Xl res = __riscv_vreinterpret_v_i32m4_i64m4(
136 __riscv_vmerge_vvm_i32m4(pzero<Packet4Xi>(c), ptrue<Packet4Xi>(c), mask, unpacket_traits<Packet4Xi>::size));
137 Packet4Xf res2 = __riscv_vreinterpret_v_i64m4_f32m4(
138 __riscv_vsra_vx_i64m4(__riscv_vand_vv_i64m4(__riscv_vsll_vx_i64m4(res, 32, unpacket_traits<Packet4Xl>::size), res,
139 unpacket_traits<Packet4Xl>::size),
140 32, unpacket_traits<Packet4Xl>::size));
141 return Packet4Xcf(res2);
142}
143
144template <>
145EIGEN_STRONG_INLINE Packet4Xcf pand<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
146 return Packet4Xcf(pand<Packet4Xf>(a.v, b.v));
147}
148
149template <>
150EIGEN_STRONG_INLINE Packet4Xcf por<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
151 return Packet4Xcf(por<Packet4Xf>(a.v, b.v));
152}
153
154template <>
155EIGEN_STRONG_INLINE Packet4Xcf pxor<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
156 return Packet4Xcf(pxor<Packet4Xf>(a.v, b.v));
157}
158
159template <>
160EIGEN_STRONG_INLINE Packet4Xcf pandnot<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
161 return Packet4Xcf(pandnot<Packet4Xf>(a.v, b.v));
162}
163
164template <>
165EIGEN_STRONG_INLINE Packet4Xcf pnot<Packet4Xcf>(const Packet4Xcf& a) {
166 return Packet4Xcf(pnot<Packet4Xf>(a.v));
167}
168
169template <>
170EIGEN_STRONG_INLINE Packet4Xcf pload<Packet4Xcf>(const std::complex<float>* from) {
171 Packet4Xf res = pload<Packet4Xf>(reinterpret_cast<const float*>(from));
172 EIGEN_DEBUG_ALIGNED_LOAD return Packet4Xcf(res);
173}
174
175template <>
176EIGEN_STRONG_INLINE Packet4Xcf ploadu<Packet4Xcf>(const std::complex<float>* from) {
177 Packet4Xf res = ploadu<Packet4Xf>(reinterpret_cast<const float*>(from));
178 EIGEN_DEBUG_UNALIGNED_LOAD return Packet4Xcf(res);
179}
180
181EIGEN_STRONG_INLINE Packet4Xcf pdup(const Packet2Xcf& a) {
182 Packet4Xul idx =
183 __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 1, unpacket_traits<Packet4Xd>::size);
184 return Packet4Xcf(__riscv_vreinterpret_v_f64m4_f32m4(
185 __riscv_vrgather_vv_f64m4(__riscv_vlmul_ext_v_f64m2_f64m4(__riscv_vreinterpret_v_f32m2_f64m2(a.v)), idx,
186 unpacket_traits<Packet4Xd>::size)));
187}
188
189template <>
190EIGEN_STRONG_INLINE Packet4Xcf ploaddup<Packet4Xcf>(const std::complex<float>* from) {
191 Packet4Xl res = ploaddup<Packet4Xl>(reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)));
192 return Packet4Xcf(__riscv_vreinterpret_v_i64m4_f32m4(res));
193}
194
195template <>
196EIGEN_STRONG_INLINE Packet4Xcf ploadquad<Packet4Xcf>(const std::complex<float>* from) {
197 Packet4Xl res = ploadquad<Packet4Xl>(reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)));
198 return Packet4Xcf(__riscv_vreinterpret_v_i64m4_f32m4(res));
199}
200
201template <>
202EIGEN_STRONG_INLINE void pstore<std::complex<float>>(std::complex<float>* to, const Packet4Xcf& from) {
203 EIGEN_DEBUG_ALIGNED_STORE pstore<float>(reinterpret_cast<float*>(to), from.v);
204}
205
206template <>
207EIGEN_STRONG_INLINE void pstoreu<std::complex<float>>(std::complex<float>* to, const Packet4Xcf& from) {
208 EIGEN_DEBUG_UNALIGNED_STORE pstoreu<float>(reinterpret_cast<float*>(to), from.v);
209}
210
211template <>
212EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet4Xcf
213pgather<std::complex<float>, Packet4Xcf>(const std::complex<float>* from, Index stride) {
214 return Packet4Xcf(__riscv_vreinterpret_v_i64m4_f32m4(pgather<int64_t, Packet4Xl>(
215 reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)), stride)));
216}
217
218template <>
219EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pscatter<std::complex<float>, Packet4Xcf>(std::complex<float>* to,
220 const Packet4Xcf& from,
221 Index stride) {
222 pscatter<int64_t, Packet4Xl>(reinterpret_cast<numext::int64_t*>(reinterpret_cast<void*>(to)),
223 __riscv_vreinterpret_v_f32m4_i64m4(from.v), stride);
224}
225
226template <>
227EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet4Xcf>(const Packet4Xcf& a) {
228 numext::int64_t res = pfirst<Packet4Xl>(__riscv_vreinterpret_v_f32m4_i64m4(a.v));
229 return numext::bit_cast<std::complex<float>>(res);
230}
231
232template <>
233EIGEN_STRONG_INLINE Packet4Xcf preverse(const Packet4Xcf& a) {
234 return Packet4Xcf(__riscv_vreinterpret_v_i64m4_f32m4(preverse<Packet4Xl>(__riscv_vreinterpret_v_f32m4_i64m4(a.v))));
235}
236
237template <>
238EIGEN_STRONG_INLINE std::complex<float> predux<Packet4Xcf>(const Packet4Xcf& a) {
239 Packet4Xl res = __riscv_vreinterpret_v_f32m4_i64m4(a.v);
240 Packet4Xf real = __riscv_vreinterpret_v_i64m4_f32m4(
241 __riscv_vand_vx_i64m4(res, 0x00000000ffffffffull, unpacket_traits<Packet4Xl>::size));
242 Packet4Xf imag = __riscv_vreinterpret_v_i64m4_f32m4(
243 __riscv_vand_vx_i64m4(res, 0xffffffff00000000ull, unpacket_traits<Packet4Xl>::size));
244 return std::complex<float>(predux<Packet4Xf>(real), predux<Packet4Xf>(imag));
245}
246
247template <>
248EIGEN_STRONG_INLINE Packet4Xcf pdiv<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
249 return pdiv_complex(a, b);
250}
251
252template <int N>
253EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(PacketBlock<Packet4Xcf, N>& kernel) {
254 numext::int64_t buffer[unpacket_traits<Packet4Xl>::size * N] = {0};
255 int i = 0;
256
257 for (i = 0; i < N; i++) {
258 __riscv_vsse64(&buffer[i], N * sizeof(numext::int64_t), __riscv_vreinterpret_v_f32m4_i64m4(kernel.packet[i].v),
259 unpacket_traits<Packet4Xl>::size);
260 }
261 for (i = 0; i < N; i++) {
262 kernel.packet[i] = Packet4Xcf(__riscv_vreinterpret_v_i64m4_f32m4(
263 __riscv_vle64_v_i64m4(&buffer[i * unpacket_traits<Packet4Xl>::size], unpacket_traits<Packet4Xl>::size)));
264 }
265}
266
267template <>
268EIGEN_STRONG_INLINE Packet4Xcf psqrt<Packet4Xcf>(const Packet4Xcf& a) {
269 return psqrt_complex(a);
270}
271
272template <>
273EIGEN_STRONG_INLINE Packet4Xcf plog<Packet4Xcf>(const Packet4Xcf& a) {
274 return plog_complex(a);
275}
276
277template <>
278EIGEN_STRONG_INLINE Packet4Xcf pexp<Packet4Xcf>(const Packet4Xcf& a) {
279 return pexp_complex(a);
280}
281
282template <typename Packet = Packet4Xcf>
283EIGEN_STRONG_INLINE Packet2Xcf predux_half(const Packet4Xcf& a) {
284 return Packet2Xcf(__riscv_vfadd_vv_f32m2(__riscv_vget_v_f32m4_f32m2(a.v, 0), __riscv_vget_v_f32m4_f32m2(a.v, 1),
285 unpacket_traits<Packet2Xf>::size));
286}
287
288EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet4Xcf, Packet4Xf)
289
290template <>
291EIGEN_STRONG_INLINE Packet1Xcf pcast<Packet1Xf, Packet1Xcf>(const Packet1Xf& a) {
292 return Packet1Xcf(a);
293}
294
295template <>
296EIGEN_STRONG_INLINE Packet1Xf pcast<Packet1Xcf, Packet1Xf>(const Packet1Xcf& a) {
297 return a.v;
298}
299
300EIGEN_STRONG_INLINE Packet1Xul __riscv_vreinterpret_v_f32m1_u64m1(const Packet1Xf& a) {
301 return __riscv_vreinterpret_v_u32m1_u64m1(__riscv_vreinterpret_v_f32m1_u32m1(a));
302}
303
304EIGEN_STRONG_INLINE Packet1Xl __riscv_vreinterpret_v_f32m1_i64m1(const Packet1Xf& a) {
305 return __riscv_vreinterpret_v_u64m1_i64m1(__riscv_vreinterpret_v_u32m1_u64m1(__riscv_vreinterpret_v_f32m1_u32m1(a)));
306}
307
308EIGEN_STRONG_INLINE Packet1Xf __riscv_vreinterpret_v_i64m1_f32m1(const Packet1Xl& a) {
309 return __riscv_vreinterpret_v_u32m1_f32m1(__riscv_vreinterpret_v_u64m1_u32m1(__riscv_vreinterpret_v_i64m1_u64m1(a)));
310}
311
312EIGEN_STRONG_INLINE Packet1Xd __riscv_vreinterpret_v_f32m1_f64m1(const Packet1Xf& a) {
313 return __riscv_vreinterpret_v_u64m1_f64m1(__riscv_vreinterpret_v_u32m1_u64m1(__riscv_vreinterpret_v_f32m1_u32m1(a)));
314}
315
316EIGEN_STRONG_INLINE Packet2Xf __riscv_vreinterpret_v_f64m2_f32m2(const Packet2Xd& a) {
317 return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vreinterpret_v_u64m2_u32m2(__riscv_vreinterpret_v_f64m2_u64m2(a)));
318}
319
320EIGEN_STRONG_INLINE void prealimag2(const Packet1Xcf& a, Packet1Xf& real, Packet1Xf& imag) {
321 const PacketMask32 mask =
322 __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
323 Packet1Xu res = __riscv_vreinterpret_v_f32m1_u32m1(a.v);
324 real = __riscv_vreinterpret_v_u32m1_f32m1(
325 __riscv_vslide1up_vx_u32m1_tumu(mask, res, res, 0, unpacket_traits<Packet1Xi>::size));
326 imag = __riscv_vreinterpret_v_u32m1_f32m1(__riscv_vslide1down_vx_u32m1_tumu(
327 __riscv_vmnot_m_b32(mask, unpacket_traits<Packet1Xi>::size), res, res, 0, unpacket_traits<Packet1Xi>::size));
328}
329
330template <>
331EIGEN_STRONG_INLINE Packet1Xcf pset1<Packet1Xcf>(const std::complex<float>& from) {
332 const numext::int64_t from2 = numext::bit_cast<numext::int64_t>(from);
333 Packet1Xf res = __riscv_vreinterpret_v_i64m1_f32m1(pset1<Packet1Xl>(from2));
334 return Packet1Xcf(res);
335}
336
337template <>
338EIGEN_STRONG_INLINE Packet1Xcf padd<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
339 return Packet1Xcf(padd<Packet1Xf>(a.v, b.v));
340}
341
342template <>
343EIGEN_STRONG_INLINE Packet1Xcf psub<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
344 return Packet1Xcf(psub<Packet1Xf>(a.v, b.v));
345}
346
347template <>
348EIGEN_STRONG_INLINE Packet1Xcf pnegate(const Packet1Xcf& a) {
349 return Packet1Xcf(pnegate<Packet1Xf>(a.v));
350}
351
352template <>
353EIGEN_STRONG_INLINE Packet1Xcf pconj(const Packet1Xcf& a) {
354 return Packet1Xcf(__riscv_vreinterpret_v_u64m1_f32m1(__riscv_vxor_vx_u64m1(
355 __riscv_vreinterpret_v_f32m1_u64m1(a.v), 0x8000000000000000ull, unpacket_traits<Packet1Xl>::size)));
356}
357
358template <>
359EIGEN_STRONG_INLINE Packet1Xcf pcplxflip<Packet1Xcf>(const Packet1Xcf& a) {
360#ifndef __riscv_zvbb
361 Packet1Xu res = __riscv_vreinterpret_v_f32m1_u32m1(a.v);
362 const PacketMask32 mask =
363 __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
364 Packet1Xu data = __riscv_vslide1down_vx_u32m1(res, 0, unpacket_traits<Packet1Xi>::size);
365 Packet1Xf res2 = __riscv_vreinterpret_v_u32m1_f32m1(
366 __riscv_vslide1up_vx_u32m1_tumu(mask, data, res, 0, unpacket_traits<Packet1Xf>::size));
367 return Packet1Xcf(res2);
368#else
369 Packet1Xf res = __riscv_vreinterpret_v_u64m1_f32m1(
370 __riscv_vror_vx_u64m1(__riscv_vreinterpret_v_f32m1_u64m1(a.v), 32, unpacket_traits<Packet1Xl>::size));
371 return Packet1Xcf(res);
372#endif
373}
374
375template <>
376EIGEN_STRONG_INLINE Packet1Xcf pmul<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
377 Packet1Xf real, imag;
378 prealimag2(a, real, imag);
379 return Packet1Xcf(pmadd<Packet1Xf>(imag, pcplxflip<Packet1Xcf>(pconj<Packet1Xcf>(b)).v, pmul<Packet1Xf>(real, b.v)));
380}
381
382template <>
383EIGEN_STRONG_INLINE Packet1Xcf pmadd<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b, const Packet1Xcf& c) {
384 Packet1Xf real, imag;
385 prealimag2(a, real, imag);
386 return Packet1Xcf(
387 pmadd<Packet1Xf>(imag, pcplxflip<Packet1Xcf>(pconj<Packet1Xcf>(b)).v, pmadd<Packet1Xf>(real, b.v, c.v)));
388}
389
390template <>
391EIGEN_STRONG_INLINE Packet1Xcf pmsub<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b, const Packet1Xcf& c) {
392 Packet1Xf real, imag;
393 prealimag2(a, real, imag);
394 return Packet1Xcf(
395 pmadd<Packet1Xf>(imag, pcplxflip<Packet1Xcf>(pconj<Packet1Xcf>(b)).v, pmsub<Packet1Xf>(real, b.v, c.v)));
396}
397
398template <>
399EIGEN_STRONG_INLINE Packet1Xcf pcmp_eq(const Packet1Xcf& a, const Packet1Xcf& b) {
400 Packet1Xi c = __riscv_vundefined_i32m1();
401 PacketMask32 mask = __riscv_vmfeq_vv_f32m1_b32(a.v, b.v, unpacket_traits<Packet1Xf>::size);
402 Packet1Xl res = __riscv_vreinterpret_v_i32m1_i64m1(
403 __riscv_vmerge_vvm_i32m1(pzero<Packet1Xi>(c), ptrue<Packet1Xi>(c), mask, unpacket_traits<Packet1Xi>::size));
404 Packet1Xf res2 = __riscv_vreinterpret_v_i64m1_f32m1(
405 __riscv_vsra_vx_i64m1(__riscv_vand_vv_i64m1(__riscv_vsll_vx_i64m1(res, 32, unpacket_traits<Packet1Xl>::size), res,
406 unpacket_traits<Packet1Xl>::size),
407 32, unpacket_traits<Packet1Xl>::size));
408 return Packet1Xcf(res2);
409}
410
411template <>
412EIGEN_STRONG_INLINE Packet1Xcf pand<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
413 return Packet1Xcf(pand<Packet1Xf>(a.v, b.v));
414}
415
416template <>
417EIGEN_STRONG_INLINE Packet1Xcf por<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
418 return Packet1Xcf(por<Packet1Xf>(a.v, b.v));
419}
420
421template <>
422EIGEN_STRONG_INLINE Packet1Xcf pxor<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
423 return Packet1Xcf(pxor<Packet1Xf>(a.v, b.v));
424}
425
426template <>
427EIGEN_STRONG_INLINE Packet1Xcf pandnot<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
428 return Packet1Xcf(pandnot<Packet1Xf>(a.v, b.v));
429}
430
431template <>
432EIGEN_STRONG_INLINE Packet1Xcf pnot<Packet1Xcf>(const Packet1Xcf& a) {
433 return Packet1Xcf(pnot<Packet1Xf>(a.v));
434}
435
436template <>
437EIGEN_STRONG_INLINE Packet1Xcf pload<Packet1Xcf>(const std::complex<float>* from) {
438 Packet1Xf res = pload<Packet1Xf>(reinterpret_cast<const float*>(from));
439 EIGEN_DEBUG_ALIGNED_LOAD return Packet1Xcf(res);
440}
441
442template <>
443EIGEN_STRONG_INLINE Packet1Xcf ploadu<Packet1Xcf>(const std::complex<float>* from) {
444 Packet1Xf res = ploadu<Packet1Xf>(reinterpret_cast<const float*>(from));
445 EIGEN_DEBUG_UNALIGNED_LOAD return Packet1Xcf(res);
446}
447
448EIGEN_STRONG_INLINE Packet2Xcf pdup(const Packet1Xcf& a) {
449 Packet2Xul idx =
450 __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 1, unpacket_traits<Packet2Xd>::size);
451 return Packet2Xcf(__riscv_vreinterpret_v_f64m2_f32m2(
452 __riscv_vrgather_vv_f64m2(__riscv_vlmul_ext_v_f64m1_f64m2(__riscv_vreinterpret_v_f32m1_f64m1(a.v)), idx,
453 unpacket_traits<Packet2Xd>::size)));
454}
455
456template <>
457EIGEN_STRONG_INLINE Packet1Xcf ploaddup<Packet1Xcf>(const std::complex<float>* from) {
458 Packet1Xl res = ploaddup<Packet1Xl>(reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)));
459 return Packet1Xcf(__riscv_vreinterpret_v_i64m1_f32m1(res));
460}
461
462template <>
463EIGEN_STRONG_INLINE Packet1Xcf ploadquad<Packet1Xcf>(const std::complex<float>* from) {
464 Packet1Xl res = ploadquad<Packet1Xl>(reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)));
465 return Packet1Xcf(__riscv_vreinterpret_v_i64m1_f32m1(res));
466}
467
468template <>
469EIGEN_STRONG_INLINE void pstore<std::complex<float>>(std::complex<float>* to, const Packet1Xcf& from) {
470 EIGEN_DEBUG_ALIGNED_STORE pstore<float>(reinterpret_cast<float*>(to), from.v);
471}
472
473template <>
474EIGEN_STRONG_INLINE void pstoreu<std::complex<float>>(std::complex<float>* to, const Packet1Xcf& from) {
475 EIGEN_DEBUG_UNALIGNED_STORE pstoreu<float>(reinterpret_cast<float*>(to), from.v);
476}
477
478template <>
479EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet1Xcf
480pgather<std::complex<float>, Packet1Xcf>(const std::complex<float>* from, Index stride) {
481 return Packet1Xcf(__riscv_vreinterpret_v_i64m1_f32m1(pgather<int64_t, Packet1Xl>(
482 reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)), stride)));
483}
484
485template <>
486EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pscatter<std::complex<float>, Packet1Xcf>(std::complex<float>* to,
487 const Packet1Xcf& from,
488 Index stride) {
489 pscatter<int64_t, Packet1Xl>(reinterpret_cast<numext::int64_t*>(reinterpret_cast<void*>(to)),
490 __riscv_vreinterpret_v_f32m1_i64m1(from.v), stride);
491}
492
493template <>
494EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet1Xcf>(const Packet1Xcf& a) {
495 numext::int64_t res = pfirst<Packet1Xl>(__riscv_vreinterpret_v_f32m1_i64m1(a.v));
496 return numext::bit_cast<std::complex<float>>(res);
497}
498
499template <>
500EIGEN_STRONG_INLINE Packet1Xcf preverse(const Packet1Xcf& a) {
501 return Packet1Xcf(__riscv_vreinterpret_v_i64m1_f32m1(preverse<Packet1Xl>(__riscv_vreinterpret_v_f32m1_i64m1(a.v))));
502}
503
504template <>
505EIGEN_STRONG_INLINE std::complex<float> predux<Packet1Xcf>(const Packet1Xcf& a) {
506 Packet1Xl res = __riscv_vreinterpret_v_f32m1_i64m1(a.v);
507 Packet1Xf real = __riscv_vreinterpret_v_i64m1_f32m1(
508 __riscv_vand_vx_i64m1(res, 0x00000000ffffffffull, unpacket_traits<Packet1Xl>::size));
509 Packet1Xf imag = __riscv_vreinterpret_v_i64m1_f32m1(
510 __riscv_vand_vx_i64m1(res, 0xffffffff00000000ull, unpacket_traits<Packet1Xl>::size));
511 return std::complex<float>(predux<Packet1Xf>(real), predux<Packet1Xf>(imag));
512}
513
514template <>
515EIGEN_STRONG_INLINE Packet1Xcf pdiv<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
516 return pdiv_complex(a, b);
517}
518
519template <int N>
520EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(PacketBlock<Packet1Xcf, N>& kernel) {
521 numext::int64_t buffer[unpacket_traits<Packet1Xl>::size * N] = {0};
522 int i = 0;
523
524 for (i = 0; i < N; i++) {
525 __riscv_vsse64(&buffer[i], N * sizeof(numext::int64_t), __riscv_vreinterpret_v_f32m1_i64m1(kernel.packet[i].v),
526 unpacket_traits<Packet1Xl>::size);
527 }
528 for (i = 0; i < N; i++) {
529 kernel.packet[i] = Packet1Xcf(__riscv_vreinterpret_v_i64m1_f32m1(
530 __riscv_vle64_v_i64m1(&buffer[i * unpacket_traits<Packet1Xl>::size], unpacket_traits<Packet1Xl>::size)));
531 }
532}
533
534template <>
535EIGEN_STRONG_INLINE Packet1Xcf psqrt<Packet1Xcf>(const Packet1Xcf& a) {
536 return psqrt_complex(a);
537}
538
539template <>
540EIGEN_STRONG_INLINE Packet1Xcf plog<Packet1Xcf>(const Packet1Xcf& a) {
541 return plog_complex(a);
542}
543
544template <>
545EIGEN_STRONG_INLINE Packet1Xcf pexp<Packet1Xcf>(const Packet1Xcf& a) {
546 return pexp_complex(a);
547}
548
549EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1Xcf, Packet1Xf)
550
551/********************************* double ************************************/
552
553template <>
554EIGEN_STRONG_INLINE Packet4Xcd pcast<Packet4Xd, Packet4Xcd>(const Packet4Xd& a) {
555 return Packet4Xcd(a);
556}
557
558template <>
559EIGEN_STRONG_INLINE Packet4Xd pcast<Packet4Xcd, Packet4Xd>(const Packet4Xcd& a) {
560 return a.v;
561}
562
563EIGEN_STRONG_INLINE void prealimag2(const Packet4Xcd& a, Packet4Xd& real, Packet4Xd& imag) {
564 const PacketMask16 mask =
565 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
566 real = __riscv_vfslide1up_vf_f64m4_tumu(mask, a.v, a.v, 0.0, unpacket_traits<Packet4Xd>::size);
567 imag = __riscv_vfslide1down_vf_f64m4_tumu(__riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size), a.v, a.v, 0.0,
568 unpacket_traits<Packet4Xd>::size);
569}
570
571template <>
572EIGEN_STRONG_INLINE Packet4Xcd pset1<Packet4Xcd>(const std::complex<double>& from) {
573 const PacketMask16 mask =
574 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
575 Packet4Xd res = __riscv_vmerge_vvm_f64m4(pset1<Packet4Xd>(from.real()), pset1<Packet4Xd>(from.imag()), mask,
576 unpacket_traits<Packet4Xd>::size);
577 return Packet4Xcd(res);
578}
579
580template <>
581EIGEN_STRONG_INLINE Packet4Xcd padd<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
582 return Packet4Xcd(padd<Packet4Xd>(a.v, b.v));
583}
584
585template <>
586EIGEN_STRONG_INLINE Packet4Xcd psub<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
587 return Packet4Xcd(psub<Packet4Xd>(a.v, b.v));
588}
589
590template <>
591EIGEN_STRONG_INLINE Packet4Xcd pnegate(const Packet4Xcd& a) {
592 return Packet4Xcd(pnegate<Packet4Xd>(a.v));
593}
594
595template <>
596EIGEN_STRONG_INLINE Packet4Xcd pconj(const Packet4Xcd& a) {
597 const PacketMask16 mask =
598 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
599 return Packet4Xcd(__riscv_vfsgnjn_vv_f64m4_tumu(mask, a.v, a.v, a.v, unpacket_traits<Packet4Xd>::size));
600}
601
602template <>
603EIGEN_STRONG_INLINE Packet4Xcd pcplxflip<Packet4Xcd>(const Packet4Xcd& a) {
604 Packet4Xul res = __riscv_vreinterpret_v_f64m4_u64m4(a.v);
605 const PacketMask16 mask =
606 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
607 Packet4Xul data = __riscv_vslide1down_vx_u64m4(res, 0, unpacket_traits<Packet4Xl>::size);
608 Packet4Xd res2 = __riscv_vreinterpret_v_u64m4_f64m4(
609 __riscv_vslide1up_vx_u64m4_tumu(mask, data, res, 0, unpacket_traits<Packet4Xl>::size));
610 return Packet4Xcd(res2);
611}
612
613template <>
614EIGEN_STRONG_INLINE Packet4Xcd pmul<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
615 Packet4Xd real, imag;
616 prealimag2(a, real, imag);
617 return Packet4Xcd(pmadd<Packet4Xd>(imag, pcplxflip<Packet4Xcd>(pconj<Packet4Xcd>(b)).v, pmul<Packet4Xd>(real, b.v)));
618}
619
620template <>
621EIGEN_STRONG_INLINE Packet4Xcd pmadd<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b, const Packet4Xcd& c) {
622 Packet4Xd real, imag;
623 prealimag2(a, real, imag);
624 return Packet4Xcd(
625 pmadd<Packet4Xd>(imag, pcplxflip<Packet4Xcd>(pconj<Packet4Xcd>(b)).v, pmadd<Packet4Xd>(real, b.v, c.v)));
626}
627
628template <>
629EIGEN_STRONG_INLINE Packet4Xcd pmsub<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b, const Packet4Xcd& c) {
630 Packet4Xd real, imag;
631 prealimag2(a, real, imag);
632 return Packet4Xcd(
633 pmadd<Packet4Xd>(imag, pcplxflip<Packet4Xcd>(pconj<Packet4Xcd>(b)).v, pmsub<Packet4Xd>(real, b.v, c.v)));
634}
635
636template <>
637EIGEN_STRONG_INLINE Packet4Xcd pcmp_eq(const Packet4Xcd& a, const Packet4Xcd& b) {
638 Packet4Xl c = __riscv_vundefined_i64m4();
639 Packet1Xsu mask =
640 __riscv_vreinterpret_v_b16_u16m1(__riscv_vmfeq_vv_f64m4_b16(a.v, b.v, unpacket_traits<Packet4Xd>::size));
641 Packet1Xsu mask_r =
642 __riscv_vsrl_vx_u16m1(__riscv_vand_vx_u16m1(mask, static_cast<short>(0xaaaa), unpacket_traits<Packet1Xs>::size),
643 1, unpacket_traits<Packet1Xs>::size);
644 mask = __riscv_vand_vv_u16m1(mask, mask_r, unpacket_traits<Packet1Xs>::size);
645 mask = __riscv_vor_vv_u16m1(__riscv_vsll_vx_u16m1(mask, 1, unpacket_traits<Packet1Xs>::size), mask,
646 unpacket_traits<Packet1Xs>::size);
647 Packet4Xd res = __riscv_vreinterpret_v_i64m4_f64m4(__riscv_vmerge_vvm_i64m4(pzero<Packet4Xl>(c), ptrue<Packet4Xl>(c),
648 __riscv_vreinterpret_v_u16m1_b16(mask),
649 unpacket_traits<Packet4Xl>::size));
650 return Packet4Xcd(res);
651}
652
653template <>
654EIGEN_STRONG_INLINE Packet4Xcd pand<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
655 return Packet4Xcd(pand<Packet4Xd>(a.v, b.v));
656}
657
658template <>
659EIGEN_STRONG_INLINE Packet4Xcd por<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
660 return Packet4Xcd(por<Packet4Xd>(a.v, b.v));
661}
662
663template <>
664EIGEN_STRONG_INLINE Packet4Xcd pxor<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
665 return Packet4Xcd(pxor<Packet4Xd>(a.v, b.v));
666}
667
668template <>
669EIGEN_STRONG_INLINE Packet4Xcd pandnot<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
670 return Packet4Xcd(pandnot<Packet4Xd>(a.v, b.v));
671}
672
673template <>
674EIGEN_STRONG_INLINE Packet4Xcd pnot<Packet4Xcd>(const Packet4Xcd& a) {
675 return Packet4Xcd(pnot<Packet4Xd>(a.v));
676}
677
678template <>
679EIGEN_STRONG_INLINE Packet4Xcd pload<Packet4Xcd>(const std::complex<double>* from) {
680 Packet4Xd res = pload<Packet4Xd>(reinterpret_cast<const double*>(from));
681 EIGEN_DEBUG_ALIGNED_LOAD return Packet4Xcd(res);
682}
683
684template <>
685EIGEN_STRONG_INLINE Packet4Xcd ploadu<Packet4Xcd>(const std::complex<double>* from) {
686 Packet4Xd res = ploadu<Packet4Xd>(reinterpret_cast<const double*>(from));
687 EIGEN_DEBUG_UNALIGNED_LOAD return Packet4Xcd(res);
688}
689
690EIGEN_STRONG_INLINE Packet4Xcd pdup(const Packet2Xcd& a) {
691 const PacketMask16 mask =
692 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x66), unpacket_traits<Packet1Xc>::size));
693 Packet4Xul idx1 =
694 __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 1, unpacket_traits<Packet4Xd>::size);
695 Packet4Xul idx2 = __riscv_vxor_vx_u64m4_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet4Xl>::size);
696 return Packet4Xcd(
697 __riscv_vrgather_vv_f64m4(__riscv_vlmul_ext_v_f64m2_f64m4(a.v), idx2, unpacket_traits<Packet4Xd>::size));
698}
699
700template <>
701EIGEN_STRONG_INLINE Packet4Xcd ploaddup<Packet4Xcd>(const std::complex<double>* from) {
702 const PacketMask16 mask =
703 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x66), unpacket_traits<Packet1Xc>::size));
704 Packet4Xul idx1 =
705 __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 1, unpacket_traits<Packet4Xd>::size);
706 Packet4Xul idx2 = __riscv_vxor_vx_u64m4_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet4Xl>::size);
707 return Packet4Xcd(__riscv_vrgather_vv_f64m4(
708 __riscv_vlmul_ext_v_f64m2_f64m4(pload<Packet2Xd>(reinterpret_cast<const double*>(from))), idx2,
709 unpacket_traits<Packet4Xd>::size));
710}
711
712template <>
713EIGEN_STRONG_INLINE Packet4Xcd ploadquad<Packet4Xcd>(const std::complex<double>* from) {
714 const PacketMask16 mask =
715 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x5a), unpacket_traits<Packet1Xc>::size));
716 Packet4Xul idx1 =
717 __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 2, unpacket_traits<Packet4Xd>::size);
718 Packet4Xul idx2 = __riscv_vxor_vx_u64m4_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet4Xl>::size);
719 return Packet4Xcd(__riscv_vrgather_vv_f64m4(
720 __riscv_vlmul_ext_v_f64m1_f64m4(pload<Packet1Xd>(reinterpret_cast<const double*>(from))), idx2,
721 unpacket_traits<Packet4Xd>::size));
722}
723
724template <>
725EIGEN_STRONG_INLINE void pstore<std::complex<double>>(std::complex<double>* to, const Packet4Xcd& from) {
726 EIGEN_DEBUG_ALIGNED_STORE pstore<double>(reinterpret_cast<double*>(to), from.v);
727}
728
729template <>
730EIGEN_STRONG_INLINE void pstoreu<std::complex<double>>(std::complex<double>* to, const Packet4Xcd& from) {
731 EIGEN_DEBUG_UNALIGNED_STORE pstoreu<double>(reinterpret_cast<double*>(to), from.v);
732}
733
734template <>
735EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet4Xcd
736pgather<std::complex<double>, Packet4Xcd>(const std::complex<double>* from, Index stride) {
737 const PacketMask16 mask =
738 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
739 const double* from2 = reinterpret_cast<const double*>(from);
740 Packet4Xd res = __riscv_vundefined_f64m4();
741 res = __riscv_vlse64_v_f64m4_tumu(mask, res, &from2[0 - (0 * stride)], stride * sizeof(double),
742 unpacket_traits<Packet4Xd>::size);
743 res =
744 __riscv_vlse64_v_f64m4_tumu(__riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size), res,
745 &from2[1 - (1 * stride)], stride * sizeof(double), unpacket_traits<Packet4Xd>::size);
746 return Packet4Xcd(res);
747}
748
749template <>
750EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pscatter<std::complex<double>, Packet4Xcd>(std::complex<double>* to,
751 const Packet4Xcd& from,
752 Index stride) {
753 const PacketMask16 mask =
754 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
755 double* to2 = reinterpret_cast<double*>(to);
756 __riscv_vsse64_v_f64m4_m(mask, &to2[0 - (0 * stride)], stride * sizeof(double), from.v,
757 unpacket_traits<Packet4Xd>::size);
758 __riscv_vsse64_v_f64m4_m(__riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size), &to2[1 - (1 * stride)],
759 stride * sizeof(double), from.v, unpacket_traits<Packet4Xd>::size);
760}
761
762template <>
763EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet4Xcd>(const Packet4Xcd& a) {
764 double real = pfirst<Packet4Xd>(a.v);
765 double imag = pfirst<Packet4Xd>(__riscv_vfslide1down_vf_f64m4(a.v, 0.0, unpacket_traits<Packet4Xd>::size));
766 return std::complex<double>(real, imag);
767}
768
769template <>
770EIGEN_STRONG_INLINE Packet4Xcd preverse(const Packet4Xcd& a) {
771 Packet4Xul idx = __riscv_vxor_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xl>::size),
772 unpacket_traits<Packet4Xl>::size - 2, unpacket_traits<Packet4Xl>::size);
773 Packet4Xd res = __riscv_vrgather_vv_f64m4(a.v, idx, unpacket_traits<Packet4Xd>::size);
774 return Packet4Xcd(res);
775}
776
777template <>
778EIGEN_STRONG_INLINE std::complex<double> predux<Packet4Xcd>(const Packet4Xcd& a) {
779 const PacketMask16 mask =
780 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
781 Packet4Xl res = __riscv_vreinterpret_v_f64m4_i64m4(a.v);
782 Packet4Xd real = __riscv_vreinterpret_v_i64m4_f64m4(
783 __riscv_vand_vx_i64m4_tumu(mask, res, res, 0, unpacket_traits<Packet4Xl>::size));
784 Packet4Xd imag = __riscv_vreinterpret_v_i64m4_f64m4(__riscv_vand_vx_i64m4_tumu(
785 __riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size), res, res, 0, unpacket_traits<Packet4Xl>::size));
786 return std::complex<double>(predux<Packet4Xd>(real), predux<Packet4Xd>(imag));
787}
788
789template <>
790EIGEN_STRONG_INLINE Packet4Xcd pdiv<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
791 return pdiv_complex(a, b);
792}
793
794template <int N>
795EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(PacketBlock<Packet4Xcd, N>& kernel) {
796 double buffer[unpacket_traits<Packet4Xd>::size * N];
797 int i = 0;
798
799 const PacketMask16 mask =
800 __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
801
802 for (i = 0; i < N; i++) {
803 __riscv_vsse64_v_f64m4_m(mask, &buffer[(i * 2) - (0 * N) + 0], N * sizeof(double), kernel.packet[i].v,
804 unpacket_traits<Packet4Xd>::size);
805 __riscv_vsse64_v_f64m4_m(__riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size),
806 &buffer[(i * 2) - (1 * N) + 1], N * sizeof(double), kernel.packet[i].v,
807 unpacket_traits<Packet4Xd>::size);
808 }
809
810 for (i = 0; i < N; i++) {
811 kernel.packet[i] = Packet4Xcd(
812 __riscv_vle64_v_f64m4(&buffer[i * unpacket_traits<Packet4Xd>::size], unpacket_traits<Packet4Xd>::size));
813 }
814}
815
816template <>
817EIGEN_STRONG_INLINE Packet4Xcd psqrt<Packet4Xcd>(const Packet4Xcd& a) {
818 return psqrt_complex(a);
819}
820
821template <>
822EIGEN_STRONG_INLINE Packet4Xcd plog<Packet4Xcd>(const Packet4Xcd& a) {
823 return plog_complex(a);
824}
825
826template <>
827EIGEN_STRONG_INLINE Packet4Xcd pexp<Packet4Xcd>(const Packet4Xcd& a) {
828 return pexp_complex(a);
829}
830
831template <typename Packet = Packet4Xcd>
832EIGEN_STRONG_INLINE Packet2Xcd predux_half(const Packet4Xcd& a) {
833 return Packet2Xcd(__riscv_vfadd_vv_f64m2(__riscv_vget_v_f64m4_f64m2(a.v, 0), __riscv_vget_v_f64m4_f64m2(a.v, 1),
834 unpacket_traits<Packet2Xd>::size));
835}
836
837EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet4Xcd, Packet4Xd)
838
839template <>
840EIGEN_STRONG_INLINE Packet1Xcd pcast<Packet1Xd, Packet1Xcd>(const Packet1Xd& a) {
841 return Packet1Xcd(a);
842}
843
844template <>
845EIGEN_STRONG_INLINE Packet1Xd pcast<Packet1Xcd, Packet1Xd>(const Packet1Xcd& a) {
846 return a.v;
847}
848
849EIGEN_STRONG_INLINE void prealimag2(const Packet1Xcd& a, Packet1Xd& real, Packet1Xd& imag) {
850 const PacketMask64 mask =
851 __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
852 real = __riscv_vfslide1up_vf_f64m1_tumu(mask, a.v, a.v, 0.0, unpacket_traits<Packet1Xd>::size);
853 imag = __riscv_vfslide1down_vf_f64m1_tumu(__riscv_vmnot_m_b64(mask, unpacket_traits<Packet1Xl>::size), a.v, a.v, 0.0,
854 unpacket_traits<Packet1Xd>::size);
855}
856
857template <>
858EIGEN_STRONG_INLINE Packet1Xcd pset1<Packet1Xcd>(const std::complex<double>& from) {
859 const PacketMask64 mask =
860 __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
861 Packet1Xd res = __riscv_vmerge_vvm_f64m1(pset1<Packet1Xd>(from.real()), pset1<Packet1Xd>(from.imag()), mask,
862 unpacket_traits<Packet1Xd>::size);
863 return Packet1Xcd(res);
864}
865
866template <>
867EIGEN_STRONG_INLINE Packet1Xcd padd<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
868 return Packet1Xcd(padd<Packet1Xd>(a.v, b.v));
869}
870
871template <>
872EIGEN_STRONG_INLINE Packet1Xcd psub<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
873 return Packet1Xcd(psub<Packet1Xd>(a.v, b.v));
874}
875
876template <>
877EIGEN_STRONG_INLINE Packet1Xcd pnegate(const Packet1Xcd& a) {
878 return Packet1Xcd(pnegate<Packet1Xd>(a.v));
879}
880
881template <>
882EIGEN_STRONG_INLINE Packet1Xcd pconj(const Packet1Xcd& a) {
883 const PacketMask64 mask =
884 __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
885 return Packet1Xcd(__riscv_vfsgnjn_vv_f64m1_tumu(mask, a.v, a.v, a.v, unpacket_traits<Packet1Xd>::size));
886}
887
888template <>
889EIGEN_STRONG_INLINE Packet1Xcd pcplxflip<Packet1Xcd>(const Packet1Xcd& a) {
890 Packet1Xul res = __riscv_vreinterpret_v_f64m1_u64m1(a.v);
891 const PacketMask64 mask =
892 __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
893 Packet1Xul data = __riscv_vslide1down_vx_u64m1(res, 0, unpacket_traits<Packet1Xl>::size);
894 Packet1Xd res2 = __riscv_vreinterpret_v_u64m1_f64m1(
895 __riscv_vslide1up_vx_u64m1_tumu(mask, data, res, 0, unpacket_traits<Packet1Xl>::size));
896 return Packet1Xcd(res2);
897}
898
899template <>
900EIGEN_STRONG_INLINE Packet1Xcd pmul<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
901 Packet1Xd real, imag;
902 prealimag2(a, real, imag);
903 return Packet1Xcd(pmadd<Packet1Xd>(imag, pcplxflip<Packet1Xcd>(pconj<Packet1Xcd>(b)).v, pmul<Packet1Xd>(real, b.v)));
904}
905
906template <>
907EIGEN_STRONG_INLINE Packet1Xcd pmadd<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b, const Packet1Xcd& c) {
908 Packet1Xd real, imag;
909 prealimag2(a, real, imag);
910 return Packet1Xcd(
911 pmadd<Packet1Xd>(imag, pcplxflip<Packet1Xcd>(pconj<Packet1Xcd>(b)).v, pmadd<Packet1Xd>(real, b.v, c.v)));
912}
913
914template <>
915EIGEN_STRONG_INLINE Packet1Xcd pmsub<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b, const Packet1Xcd& c) {
916 Packet1Xd real, imag;
917 prealimag2(a, real, imag);
918 return Packet1Xcd(
919 pmadd<Packet1Xd>(imag, pcplxflip<Packet1Xcd>(pconj<Packet1Xcd>(b)).v, pmsub<Packet1Xd>(real, b.v, c.v)));
920}
921
922template <>
923EIGEN_STRONG_INLINE Packet1Xcd pcmp_eq(const Packet1Xcd& a, const Packet1Xcd& b) {
924 Packet1Xl c = __riscv_vundefined_i64m1();
925 Packet1Xul mask =
926 __riscv_vreinterpret_v_b64_u64m1(__riscv_vmfeq_vv_f64m1_b64(a.v, b.v, unpacket_traits<Packet1Xd>::size));
927 Packet1Xul mask_r =
928 __riscv_vsrl_vx_u64m1(__riscv_vand_vx_u64m1(mask, 0xaaaaaaaaaaaaaaaa, unpacket_traits<Packet1Xl>::size), 1,
929 unpacket_traits<Packet1Xl>::size);
930 mask = __riscv_vand_vv_u64m1(mask, mask_r, unpacket_traits<Packet1Xl>::size);
931 mask = __riscv_vor_vv_u64m1(__riscv_vsll_vx_u64m1(mask, 1, unpacket_traits<Packet1Xl>::size), mask,
932 unpacket_traits<Packet1Xl>::size);
933 Packet1Xd res = __riscv_vreinterpret_v_i64m1_f64m1(__riscv_vmerge_vvm_i64m1(pzero<Packet1Xl>(c), ptrue<Packet1Xl>(c),
934 __riscv_vreinterpret_v_u64m1_b64(mask),
935 unpacket_traits<Packet1Xl>::size));
936 return Packet1Xcd(res);
937}
938
939template <>
940EIGEN_STRONG_INLINE Packet1Xcd pand<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
941 return Packet1Xcd(pand<Packet1Xd>(a.v, b.v));
942}
943
944template <>
945EIGEN_STRONG_INLINE Packet1Xcd por<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
946 return Packet1Xcd(por<Packet1Xd>(a.v, b.v));
947}
948
949template <>
950EIGEN_STRONG_INLINE Packet1Xcd pxor<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
951 return Packet1Xcd(pxor<Packet1Xd>(a.v, b.v));
952}
953
954template <>
955EIGEN_STRONG_INLINE Packet1Xcd pandnot<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
956 return Packet1Xcd(pandnot<Packet1Xd>(a.v, b.v));
957}
958
959template <>
960EIGEN_STRONG_INLINE Packet1Xcd pnot<Packet1Xcd>(const Packet1Xcd& a) {
961 return Packet1Xcd(pnot<Packet1Xd>(a.v));
962}
963
964template <>
965EIGEN_STRONG_INLINE Packet1Xcd pload<Packet1Xcd>(const std::complex<double>* from) {
966 Packet1Xd res = pload<Packet1Xd>(reinterpret_cast<const double*>(from));
967 EIGEN_DEBUG_ALIGNED_LOAD return Packet1Xcd(res);
968}
969
970template <>
971EIGEN_STRONG_INLINE Packet1Xcd ploadu<Packet1Xcd>(const std::complex<double>* from) {
972 Packet1Xd res = ploadu<Packet1Xd>(reinterpret_cast<const double*>(from));
973 EIGEN_DEBUG_UNALIGNED_LOAD return Packet1Xcd(res);
974}
975
976EIGEN_STRONG_INLINE Packet2Xcd pdup(const Packet1Xcd& a) {
977 const PacketMask32 mask =
978 __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0x66), unpacket_traits<Packet1Xc>::size));
979 Packet2Xul idx1 =
980 __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 1, unpacket_traits<Packet2Xd>::size);
981 Packet2Xul idx2 = __riscv_vxor_vx_u64m2_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet2Xl>::size);
982 return Packet2Xcd(
983 __riscv_vrgather_vv_f64m2(__riscv_vlmul_ext_v_f64m1_f64m2(a.v), idx2, unpacket_traits<Packet2Xd>::size));
984}
985
986template <>
987EIGEN_STRONG_INLINE Packet1Xcd ploaddup<Packet1Xcd>(const std::complex<double>* from) {
988 const PacketMask64 mask =
989 __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0x66), unpacket_traits<Packet1Xc>::size));
990 Packet1Xul idx1 =
991 __riscv_vsrl_vx_u64m1(__riscv_vid_v_u64m1(unpacket_traits<Packet1Xd>::size), 1, unpacket_traits<Packet1Xd>::size);
992 Packet1Xul idx2 = __riscv_vxor_vx_u64m1_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet1Xl>::size);
993 return Packet1Xcd(__riscv_vrgather_vv_f64m1(pload<Packet1Xd>(reinterpret_cast<const double*>(from)), idx2,
994 unpacket_traits<Packet1Xd>::size));
995}
996
997template <>
998EIGEN_STRONG_INLINE Packet1Xcd ploadquad<Packet1Xcd>(const std::complex<double>* from) {
999 const PacketMask64 mask =
1000 __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0x5a), unpacket_traits<Packet1Xc>::size));
1001 Packet1Xul idx1 =
1002 __riscv_vsrl_vx_u64m1(__riscv_vid_v_u64m1(unpacket_traits<Packet1Xd>::size), 2, unpacket_traits<Packet1Xd>::size);
1003 Packet1Xul idx2 = __riscv_vxor_vx_u64m1_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet1Xl>::size);
1004 return Packet1Xcd(__riscv_vrgather_vv_f64m1(pload<Packet1Xd>(reinterpret_cast<const double*>(from)), idx2,
1005 unpacket_traits<Packet1Xd>::size));
1006}
1007
1008template <>
1009EIGEN_STRONG_INLINE void pstore<std::complex<double>>(std::complex<double>* to, const Packet1Xcd& from) {
1010 EIGEN_DEBUG_ALIGNED_STORE pstore<double>(reinterpret_cast<double*>(to), from.v);
1011}
1012
1013template <>
1014EIGEN_STRONG_INLINE void pstoreu<std::complex<double>>(std::complex<double>* to, const Packet1Xcd& from) {
1015 EIGEN_DEBUG_UNALIGNED_STORE pstoreu<double>(reinterpret_cast<double*>(to), from.v);
1016}
1017
1018template <>
1019EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet1Xcd
1020pgather<std::complex<double>, Packet1Xcd>(const std::complex<double>* from, Index stride) {
1021 const PacketMask64 mask =
1022 __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
1023 const double* from2 = reinterpret_cast<const double*>(from);
1024 Packet1Xd res = __riscv_vundefined_f64m1();
1025 res = __riscv_vlse64_v_f64m1_tumu(mask, res, &from2[0 - (0 * stride)], stride * sizeof(double),
1026 unpacket_traits<Packet1Xd>::size);
1027 res =
1028 __riscv_vlse64_v_f64m1_tumu(__riscv_vmnot_m_b64(mask, unpacket_traits<Packet1Xl>::size), res,
1029 &from2[1 - (1 * stride)], stride * sizeof(double), unpacket_traits<Packet1Xd>::size);
1030 return Packet1Xcd(res);
1031}
1032
1033template <>
1034EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pscatter<std::complex<double>, Packet1Xcd>(std::complex<double>* to,
1035 const Packet1Xcd& from,
1036 Index stride) {
1037 const PacketMask64 mask =
1038 __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
1039 double* to2 = reinterpret_cast<double*>(to);
1040 __riscv_vsse64_v_f64m1_m(mask, &to2[0 - (0 * stride)], stride * sizeof(double), from.v,
1041 unpacket_traits<Packet1Xd>::size);
1042 __riscv_vsse64_v_f64m1_m(__riscv_vmnot_m_b64(mask, unpacket_traits<Packet1Xl>::size), &to2[1 - (1 * stride)],
1043 stride * sizeof(double), from.v, unpacket_traits<Packet1Xd>::size);
1044}
1045
1046template <>
1047EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet1Xcd>(const Packet1Xcd& a) {
1048 double real = pfirst<Packet1Xd>(a.v);
1049 double imag = pfirst<Packet1Xd>(__riscv_vfslide1down_vf_f64m1(a.v, 0.0, unpacket_traits<Packet1Xd>::size));
1050 return std::complex<double>(real, imag);
1051}
1052
1053template <>
1054EIGEN_STRONG_INLINE Packet1Xcd preverse(const Packet1Xcd& a) {
1055 Packet1Xul idx = __riscv_vxor_vx_u64m1(__riscv_vid_v_u64m1(unpacket_traits<Packet1Xl>::size),
1056 unpacket_traits<Packet1Xl>::size - 2, unpacket_traits<Packet1Xl>::size);
1057 Packet1Xd res = __riscv_vrgather_vv_f64m1(a.v, idx, unpacket_traits<Packet1Xd>::size);
1058 return Packet1Xcd(res);
1059}
1060
1061template <>
1062EIGEN_STRONG_INLINE std::complex<double> predux<Packet1Xcd>(const Packet1Xcd& a) {
1063 const PacketMask64 mask =
1064 __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
1065 Packet1Xl res = __riscv_vreinterpret_v_f64m1_i64m1(a.v);
1066 Packet1Xd real = __riscv_vreinterpret_v_i64m1_f64m1(
1067 __riscv_vand_vx_i64m1_tumu(mask, res, res, 0, unpacket_traits<Packet1Xl>::size));
1068 Packet1Xd imag = __riscv_vreinterpret_v_i64m1_f64m1(__riscv_vand_vx_i64m1_tumu(
1069 __riscv_vmnot_m_b64(mask, unpacket_traits<Packet1Xl>::size), res, res, 0, unpacket_traits<Packet1Xl>::size));
1070 return std::complex<double>(predux<Packet1Xd>(real), predux<Packet1Xd>(imag));
1071}
1072
1073template <>
1074EIGEN_STRONG_INLINE Packet1Xcd pdiv<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
1075 return pdiv_complex(a, b);
1076}
1077
1078template <int N>
1079EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(PacketBlock<Packet1Xcd, N>& kernel) {
1080 double buffer[unpacket_traits<Packet1Xd>::size * N];
1081 int i = 0;
1082
1083 const PacketMask64 mask =
1084 __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
1085
1086 for (i = 0; i < N; i++) {
1087 __riscv_vsse64_v_f64m1_m(mask, &buffer[(i * 2) - (0 * N) + 0], N * sizeof(double), kernel.packet[i].v,
1088 unpacket_traits<Packet1Xd>::size);
1089 __riscv_vsse64_v_f64m1_m(__riscv_vmnot_m_b64(mask, unpacket_traits<Packet1Xl>::size),
1090 &buffer[(i * 2) - (1 * N) + 1], N * sizeof(double), kernel.packet[i].v,
1091 unpacket_traits<Packet1Xd>::size);
1092 }
1093
1094 for (i = 0; i < N; i++) {
1095 kernel.packet[i] = Packet1Xcd(
1096 __riscv_vle64_v_f64m1(&buffer[i * unpacket_traits<Packet1Xd>::size], unpacket_traits<Packet1Xd>::size));
1097 }
1098}
1099
1100template <>
1101EIGEN_STRONG_INLINE Packet1Xcd psqrt<Packet1Xcd>(const Packet1Xcd& a) {
1102 return psqrt_complex(a);
1103}
1104
1105template <>
1106EIGEN_STRONG_INLINE Packet1Xcd plog<Packet1Xcd>(const Packet1Xcd& a) {
1107 return plog_complex(a);
1108}
1109
1110template <>
1111EIGEN_STRONG_INLINE Packet1Xcd pexp<Packet1Xcd>(const Packet1Xcd& a) {
1112 return pexp_complex(a);
1113}
1114
1115EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1Xcd, Packet1Xd)
1116
1117} // end namespace internal
1118
1119} // end namespace Eigen
1120
1121#endif // EIGEN_COMPLEX2_RVV10_H