Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.0
 
Loading...
Searching...
No Matches
MSA/Complex.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2018 Wave Computing, Inc.
5// Written by:
6// Chris Larsen
7// Alexey Frunze (afrunze@wavecomp.com)
8//
9// This Source Code Form is subject to the terms of the Mozilla
10// Public License v. 2.0. If a copy of the MPL was not distributed
11// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
12
13#ifndef EIGEN_COMPLEX_MSA_H
14#define EIGEN_COMPLEX_MSA_H
15
16#include <iostream>
17
18namespace Eigen {
19
20namespace internal {
21
22//---------- float ----------
23struct Packet2cf {
24 EIGEN_STRONG_INLINE Packet2cf() {
25 }
26 EIGEN_STRONG_INLINE explicit Packet2cf(const std::complex<float>& a,
27 const std::complex<float>& b) {
28 Packet4f t = { std::real(a), std::imag(a), std::real(b), std::imag(b) };
29 v = t;
30 }
31 EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {
32 }
33 EIGEN_STRONG_INLINE Packet2cf(const Packet2cf& a) : v(a.v) {
34 }
35 EIGEN_STRONG_INLINE Packet2cf& operator=(const Packet2cf& b) {
36 v = b.v;
37 return *this;
38 }
39 EIGEN_STRONG_INLINE Packet2cf conjugate(void) const {
40 return Packet2cf((Packet4f)__builtin_msa_bnegi_d((v2u64)v, 63));
41 }
42 EIGEN_STRONG_INLINE Packet2cf& operator*=(const Packet2cf& b) {
43 Packet4f v1, v2;
44
45 // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
46 v1 = (Packet4f)__builtin_msa_ilvev_w((v4i32)v, (v4i32)v);
47 // Get the imag values of a | a1_im | a1_im | a2_im | a2_im |
48 v2 = (Packet4f)__builtin_msa_ilvod_w((v4i32)v, (v4i32)v);
49 // Multiply the real a with b
50 v1 = pmul(v1, b.v);
51 // Multiply the imag a with b
52 v2 = pmul(v2, b.v);
53 // Conjugate v2
54 v2 = Packet2cf(v2).conjugate().v;
55 // Swap real/imag elements in v2.
56 v2 = (Packet4f)__builtin_msa_shf_w((v4i32)v2, EIGEN_MSA_SHF_I8(1, 0, 3, 2));
57 // Add and return the result
58 v = padd(v1, v2);
59 return *this;
60 }
61 EIGEN_STRONG_INLINE Packet2cf operator*(const Packet2cf& b) const {
62 return Packet2cf(*this) *= b;
63 }
64 EIGEN_STRONG_INLINE Packet2cf& operator+=(const Packet2cf& b) {
65 v = padd(v, b.v);
66 return *this;
67 }
68 EIGEN_STRONG_INLINE Packet2cf operator+(const Packet2cf& b) const {
69 return Packet2cf(*this) += b;
70 }
71 EIGEN_STRONG_INLINE Packet2cf& operator-=(const Packet2cf& b) {
72 v = psub(v, b.v);
73 return *this;
74 }
75 EIGEN_STRONG_INLINE Packet2cf operator-(const Packet2cf& b) const {
76 return Packet2cf(*this) -= b;
77 }
78 EIGEN_STRONG_INLINE Packet2cf& operator/=(const Packet2cf& b) {
79 *this *= b.conjugate();
80 Packet4f s = pmul<Packet4f>(b.v, b.v);
81 s = padd(s, (Packet4f)__builtin_msa_shf_w((v4i32)s, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
82 v = pdiv(v, s);
83 return *this;
84 }
85 EIGEN_STRONG_INLINE Packet2cf operator/(const Packet2cf& b) const {
86 return Packet2cf(*this) /= b;
87 }
88 EIGEN_STRONG_INLINE Packet2cf operator-(void) const {
89 return Packet2cf(pnegate(v));
90 }
91
92 Packet4f v;
93};
94
95inline std::ostream& operator<<(std::ostream& os, const Packet2cf& value) {
96 os << "[ (" << value.v[0] << ", " << value.v[1]
97 << "i),"
98 " ("
99 << value.v[2] << ", " << value.v[3] << "i) ]";
100 return os;
101}
102
103template <>
104struct packet_traits<std::complex<float> > : default_packet_traits {
105 typedef Packet2cf type;
106 typedef Packet2cf half;
107 enum {
108 Vectorizable = 1,
109 AlignedOnScalar = 1,
110 size = 2,
111 HasHalfPacket = 0,
112
113 HasAdd = 1,
114 HasSub = 1,
115 HasMul = 1,
116 HasDiv = 1,
117 HasNegate = 1,
118 HasAbs = 0,
119 HasAbs2 = 0,
120 HasMin = 0,
121 HasMax = 0,
122 HasSetLinear = 0,
123 HasBlend = 1
124 };
125};
126
127template <>
128struct unpacket_traits<Packet2cf> {
129 typedef std::complex<float> type;
130 enum { size = 2, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
131 typedef Packet2cf half;
132};
133
134template <>
135EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>& from) {
136 EIGEN_MSA_DEBUG;
137
138 float f0 = from.real(), f1 = from.imag();
139 Packet4f v0 = { f0, f0, f0, f0 };
140 Packet4f v1 = { f1, f1, f1, f1 };
141 return Packet2cf((Packet4f)__builtin_msa_ilvr_w((Packet4i)v1, (Packet4i)v0));
142}
143
144template <>
145EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
146 EIGEN_MSA_DEBUG;
147
148 return a + b;
149}
150
151template <>
152EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
153 EIGEN_MSA_DEBUG;
154
155 return a - b;
156}
157
158template <>
159EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) {
160 EIGEN_MSA_DEBUG;
161
162 return -a;
163}
164
165template <>
166EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) {
167 EIGEN_MSA_DEBUG;
168
169 return a.conjugate();
170}
171
172template <>
173EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
174 EIGEN_MSA_DEBUG;
175
176 return a * b;
177}
178
179template <>
180EIGEN_STRONG_INLINE Packet2cf pand<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
181 EIGEN_MSA_DEBUG;
182
183 return Packet2cf(pand(a.v, b.v));
184}
185
186template <>
187EIGEN_STRONG_INLINE Packet2cf por<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
188 EIGEN_MSA_DEBUG;
189
190 return Packet2cf(por(a.v, b.v));
191}
192
193template <>
194EIGEN_STRONG_INLINE Packet2cf pxor<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
195 EIGEN_MSA_DEBUG;
196
197 return Packet2cf(pxor(a.v, b.v));
198}
199
200template <>
201EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
202 EIGEN_MSA_DEBUG;
203
204 return Packet2cf(pandnot(a.v, b.v));
205}
206
207template <>
208EIGEN_STRONG_INLINE Packet2cf pload<Packet2cf>(const std::complex<float>* from) {
209 EIGEN_MSA_DEBUG;
210
211 EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from));
212}
213
214template <>
215EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from) {
216 EIGEN_MSA_DEBUG;
217
218 EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from));
219}
220
221template <>
222EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from) {
223 EIGEN_MSA_DEBUG;
224
225 return pset1<Packet2cf>(*from);
226}
227
228template <>
229EIGEN_STRONG_INLINE void pstore<std::complex<float> >(std::complex<float>* to,
230 const Packet2cf& from) {
231 EIGEN_MSA_DEBUG;
232
233 EIGEN_DEBUG_ALIGNED_STORE pstore<float>((float*)to, from.v);
234}
235
236template <>
237EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float>* to,
238 const Packet2cf& from) {
239 EIGEN_MSA_DEBUG;
240
241 EIGEN_DEBUG_UNALIGNED_STORE pstoreu<float>((float*)to, from.v);
242}
243
244template <>
245EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(
246 const std::complex<float>* from, Index stride) {
247 EIGEN_MSA_DEBUG;
248
249 return Packet2cf(from[0 * stride], from[1 * stride]);
250}
251
252template <>
253EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to,
254 const Packet2cf& from,
255 Index stride) {
256 EIGEN_MSA_DEBUG;
257
258 *to = std::complex<float>(from.v[0], from.v[1]);
259 to += stride;
260 *to = std::complex<float>(from.v[2], from.v[3]);
261}
262
263template <>
264EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float>* addr) {
265 EIGEN_MSA_DEBUG;
266
267 prefetch(reinterpret_cast<const float*>(addr));
268}
269
270template <>
271EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a) {
272 EIGEN_MSA_DEBUG;
273
274 return std::complex<float>(a.v[0], a.v[1]);
275}
276
277template <>
278EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) {
279 EIGEN_MSA_DEBUG;
280
281 return Packet2cf((Packet4f)__builtin_msa_shf_w((v4i32)a.v, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
282}
283
284template <>
285EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& a) {
286 EIGEN_MSA_DEBUG;
287
288 return Packet2cf((Packet4f)__builtin_msa_shf_w((v4i32)a.v, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
289}
290
291template <>
292EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a) {
293 EIGEN_MSA_DEBUG;
294
295 Packet4f value = (Packet4f)preverse((Packet2d)a.v);
296 value += a.v;
297 return std::complex<float>(value[0], value[1]);
298}
299
300template <>
301EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a) {
302 EIGEN_MSA_DEBUG;
303
304 return std::complex<float>((a.v[0] * a.v[2]) - (a.v[1] * a.v[3]),
305 (a.v[0] * a.v[3]) + (a.v[1] * a.v[2]));
306}
307
308EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf, Packet4f)
309
310template <>
311EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
312 EIGEN_MSA_DEBUG;
313
314 return a / b;
315}
316
317inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet2cf, 2>& value) {
318 os << "[ " << value.packet[0] << ", " << std::endl << " " << value.packet[1] << " ]";
319 return os;
320}
321
322EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2cf, 2>& kernel) {
323 EIGEN_MSA_DEBUG;
324
325 Packet4f tmp =
326 (Packet4f)__builtin_msa_ilvl_d((v2i64)kernel.packet[1].v, (v2i64)kernel.packet[0].v);
327 kernel.packet[0].v =
328 (Packet4f)__builtin_msa_ilvr_d((v2i64)kernel.packet[1].v, (v2i64)kernel.packet[0].v);
329 kernel.packet[1].v = tmp;
330}
331
332template <>
333EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket,
334 const Packet2cf& elsePacket) {
335 return (Packet2cf)(Packet4f)pblend<Packet2d>(ifPacket, (Packet2d)thenPacket.v,
336 (Packet2d)elsePacket.v);
337}
338
339//---------- double ----------
340
341struct Packet1cd {
342 EIGEN_STRONG_INLINE Packet1cd() {
343 }
344 EIGEN_STRONG_INLINE explicit Packet1cd(const std::complex<double>& a) {
345 v[0] = std::real(a);
346 v[1] = std::imag(a);
347 }
348 EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {
349 }
350 EIGEN_STRONG_INLINE Packet1cd(const Packet1cd& a) : v(a.v) {
351 }
352 EIGEN_STRONG_INLINE Packet1cd& operator=(const Packet1cd& b) {
353 v = b.v;
354 return *this;
355 }
356 EIGEN_STRONG_INLINE Packet1cd conjugate(void) const {
357 static const v2u64 p2ul_CONJ_XOR = { 0x0, 0x8000000000000000 };
358 return (Packet1cd)pxor(v, (Packet2d)p2ul_CONJ_XOR);
359 }
360 EIGEN_STRONG_INLINE Packet1cd& operator*=(const Packet1cd& b) {
361 Packet2d v1, v2;
362
363 // Get the real values of a | a1_re | a1_re
364 v1 = (Packet2d)__builtin_msa_ilvev_d((v2i64)v, (v2i64)v);
365 // Get the imag values of a | a1_im | a1_im
366 v2 = (Packet2d)__builtin_msa_ilvod_d((v2i64)v, (v2i64)v);
367 // Multiply the real a with b
368 v1 = pmul(v1, b.v);
369 // Multiply the imag a with b
370 v2 = pmul(v2, b.v);
371 // Conjugate v2
372 v2 = Packet1cd(v2).conjugate().v;
373 // Swap real/imag elements in v2.
374 v2 = (Packet2d)__builtin_msa_shf_w((v4i32)v2, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
375 // Add and return the result
376 v = padd(v1, v2);
377 return *this;
378 }
379 EIGEN_STRONG_INLINE Packet1cd operator*(const Packet1cd& b) const {
380 return Packet1cd(*this) *= b;
381 }
382 EIGEN_STRONG_INLINE Packet1cd& operator+=(const Packet1cd& b) {
383 v = padd(v, b.v);
384 return *this;
385 }
386 EIGEN_STRONG_INLINE Packet1cd operator+(const Packet1cd& b) const {
387 return Packet1cd(*this) += b;
388 }
389 EIGEN_STRONG_INLINE Packet1cd& operator-=(const Packet1cd& b) {
390 v = psub(v, b.v);
391 return *this;
392 }
393 EIGEN_STRONG_INLINE Packet1cd operator-(const Packet1cd& b) const {
394 return Packet1cd(*this) -= b;
395 }
396 EIGEN_STRONG_INLINE Packet1cd& operator/=(const Packet1cd& b) {
397 *this *= b.conjugate();
398 Packet2d s = pmul<Packet2d>(b.v, b.v);
399 s = padd(s, preverse<Packet2d>(s));
400 v = pdiv(v, s);
401 return *this;
402 }
403 EIGEN_STRONG_INLINE Packet1cd operator/(const Packet1cd& b) const {
404 return Packet1cd(*this) /= b;
405 }
406 EIGEN_STRONG_INLINE Packet1cd operator-(void) const {
407 return Packet1cd(pnegate(v));
408 }
409
410 Packet2d v;
411};
412
413inline std::ostream& operator<<(std::ostream& os, const Packet1cd& value) {
414 os << "[ (" << value.v[0] << ", " << value.v[1] << "i) ]";
415 return os;
416}
417
418template <>
419struct packet_traits<std::complex<double> > : default_packet_traits {
420 typedef Packet1cd type;
421 typedef Packet1cd half;
422 enum {
423 Vectorizable = 1,
424 AlignedOnScalar = 0,
425 size = 1,
426 HasHalfPacket = 0,
427
428 HasAdd = 1,
429 HasSub = 1,
430 HasMul = 1,
431 HasDiv = 1,
432 HasNegate = 1,
433 HasAbs = 0,
434 HasAbs2 = 0,
435 HasMin = 0,
436 HasMax = 0,
437 HasSetLinear = 0
438 };
439};
440
441template <>
442struct unpacket_traits<Packet1cd> {
443 typedef std::complex<double> type;
444 enum { size = 1, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
445 typedef Packet1cd half;
446};
447
448template <>
449EIGEN_STRONG_INLINE Packet1cd pload<Packet1cd>(const std::complex<double>* from) {
450 EIGEN_MSA_DEBUG;
451
452 EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from));
453}
454
455template <>
456EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) {
457 EIGEN_MSA_DEBUG;
458
459 EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from));
460}
461
462template <>
463EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>& from) {
464 EIGEN_MSA_DEBUG;
465
466 return Packet1cd(from);
467}
468
469template <>
470EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
471 EIGEN_MSA_DEBUG;
472
473 return a + b;
474}
475
476template <>
477EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
478 EIGEN_MSA_DEBUG;
479
480 return a - b;
481}
482
483template <>
484EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) {
485 EIGEN_MSA_DEBUG;
486
487 return -a;
488}
489
490template <>
491EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) {
492 EIGEN_MSA_DEBUG;
493
494 return a.conjugate();
495}
496
497template <>
498EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
499 EIGEN_MSA_DEBUG;
500
501 return a * b;
502}
503
504template <>
505EIGEN_STRONG_INLINE Packet1cd pand<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
506 EIGEN_MSA_DEBUG;
507
508 return Packet1cd(pand(a.v, b.v));
509}
510
511template <>
512EIGEN_STRONG_INLINE Packet1cd por<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
513 EIGEN_MSA_DEBUG;
514
515 return Packet1cd(por(a.v, b.v));
516}
517
518template <>
519EIGEN_STRONG_INLINE Packet1cd pxor<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
520 EIGEN_MSA_DEBUG;
521
522 return Packet1cd(pxor(a.v, b.v));
523}
524
525template <>
526EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
527 EIGEN_MSA_DEBUG;
528
529 return Packet1cd(pandnot(a.v, b.v));
530}
531
532template <>
533EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) {
534 EIGEN_MSA_DEBUG;
535
536 return pset1<Packet1cd>(*from);
537}
538
539template <>
540EIGEN_STRONG_INLINE void pstore<std::complex<double> >(std::complex<double>* to,
541 const Packet1cd& from) {
542 EIGEN_MSA_DEBUG;
543
544 EIGEN_DEBUG_ALIGNED_STORE pstore<double>((double*)to, from.v);
545}
546
547template <>
548EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double>* to,
549 const Packet1cd& from) {
550 EIGEN_MSA_DEBUG;
551
552 EIGEN_DEBUG_UNALIGNED_STORE pstoreu<double>((double*)to, from.v);
553}
554
555template <>
556EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double>* addr) {
557 EIGEN_MSA_DEBUG;
558
559 prefetch(reinterpret_cast<const double*>(addr));
560}
561
562template <>
563EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(
564 const std::complex<double>* from, Index stride __attribute__((unused))) {
565 EIGEN_MSA_DEBUG;
566
567 Packet1cd res;
568 res.v[0] = std::real(from[0]);
569 res.v[1] = std::imag(from[0]);
570 return res;
571}
572
573template <>
574EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to,
575 const Packet1cd& from,
576 Index stride
577 __attribute__((unused))) {
578 EIGEN_MSA_DEBUG;
579
580 pstore(to, from);
581}
582
583template <>
584EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet1cd>(const Packet1cd& a) {
585 EIGEN_MSA_DEBUG;
586
587 return std::complex<double>(a.v[0], a.v[1]);
588}
589
590template <>
591EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) {
592 EIGEN_MSA_DEBUG;
593
594 return a;
595}
596
597template <>
598EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) {
599 EIGEN_MSA_DEBUG;
600
601 return pfirst(a);
602}
603
604template <>
605EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) {
606 EIGEN_MSA_DEBUG;
607
608 return pfirst(a);
609}
610
611EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd, Packet2d)
612
613template <>
614EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
615 EIGEN_MSA_DEBUG;
616
617 return a / b;
618}
619
620EIGEN_STRONG_INLINE Packet1cd pcplxflip /*<Packet1cd>*/ (const Packet1cd& x) {
621 EIGEN_MSA_DEBUG;
622
623 return Packet1cd(preverse(Packet2d(x.v)));
624}
625
626inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet1cd, 2>& value) {
627 os << "[ " << value.packet[0] << ", " << std::endl << " " << value.packet[1] << " ]";
628 return os;
629}
630
631EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd, 2>& kernel) {
632 EIGEN_MSA_DEBUG;
633
634 Packet2d v1, v2;
635
636 v1 = (Packet2d)__builtin_msa_ilvev_d((v2i64)kernel.packet[0].v, (v2i64)kernel.packet[1].v);
637 // Get the imag values of a
638 v2 = (Packet2d)__builtin_msa_ilvod_d((v2i64)kernel.packet[0].v, (v2i64)kernel.packet[1].v);
639
640 kernel.packet[0].v = v1;
641 kernel.packet[1].v = v2;
642}
643
644} // end namespace internal
645
646} // end namespace Eigen
647
648#endif // EIGEN_COMPLEX_MSA_H
@ Aligned16
Definition: Constants.h:235
Namespace containing all symbols from the Eigen library.
Definition: Core:141
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74