MSA/Complex.h
Go to the documentation of this file.
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 
18 namespace Eigen {
19 
20 namespace internal {
21 
22 //---------- float ----------
23 struct Packet2cf {
25  }
26  EIGEN_STRONG_INLINE explicit Packet2cf(const std::complex<float>& a,
27  const std::complex<float>& b) {
29  v = t;
30  }
31  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {
32  }
34  }
36  v = b.v;
37  return *this;
38  }
40  return Packet2cf((Packet4f)__builtin_msa_bnegi_d((v2u64)v, 63));
41  }
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  }
62  return Packet2cf(*this) *= b;
63  }
65  v = padd(v, b.v);
66  return *this;
67  }
69  return Packet2cf(*this) += b;
70  }
72  v = psub(v, b.v);
73  return *this;
74  }
76  return Packet2cf(*this) -= b;
77  }
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  }
86  return Packet2cf(*this) /= b;
87  }
89  return Packet2cf(pnegate(v));
90  }
91 
92  Packet4f v;
93 };
94 
95 inline 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 
103 template <>
104 struct 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,
124  };
125 };
126 
127 template <>
128 struct unpacket_traits<Packet2cf> {
129  typedef std::complex<float> type;
131  typedef Packet2cf half;
132 };
133 
134 template <>
135 EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>& from) {
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 
144 template <>
145 EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
147 
148  return a + b;
149 }
150 
151 template <>
152 EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
154 
155  return a - b;
156 }
157 
158 template <>
159 EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) {
161 
162  return -a;
163 }
164 
165 template <>
166 EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) {
168 
169  return a.conjugate();
170 }
171 
172 template <>
175 
176  return a * b;
177 }
178 
179 template <>
180 EIGEN_STRONG_INLINE Packet2cf pand<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
182 
183  return Packet2cf(pand(a.v, b.v));
184 }
185 
186 template <>
187 EIGEN_STRONG_INLINE Packet2cf por<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
189 
190  return Packet2cf(por(a.v, b.v));
191 }
192 
193 template <>
194 EIGEN_STRONG_INLINE Packet2cf pxor<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
196 
197  return Packet2cf(pxor(a.v, b.v));
198 }
199 
200 template <>
201 EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
203 
204  return Packet2cf(pandnot(a.v, b.v));
205 }
206 
207 template <>
208 EIGEN_STRONG_INLINE Packet2cf pload<Packet2cf>(const std::complex<float>* from) {
210 
211  EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from));
212 }
213 
214 template <>
215 EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from) {
217 
218  EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from));
219 }
220 
221 template <>
222 EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from) {
224 
225  return pset1<Packet2cf>(*from);
226 }
227 
228 template <>
229 EIGEN_STRONG_INLINE void pstore<std::complex<float> >(std::complex<float>* to,
230  const Packet2cf& from) {
232 
233  EIGEN_DEBUG_ALIGNED_STORE pstore<float>((float*)to, from.v);
234 }
235 
236 template <>
237 EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float>* to,
238  const Packet2cf& from) {
240 
241  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<float>((float*)to, from.v);
242 }
243 
244 template <>
245 EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(
246  const std::complex<float>* from, Index stride) {
248 
249  return Packet2cf(from[0 * stride], from[1 * stride]);
250 }
251 
252 template <>
253 EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to,
254  const Packet2cf& from,
255  Index stride) {
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 
263 template <>
264 EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float>* addr) {
266 
267  prefetch(reinterpret_cast<const float*>(addr));
268 }
269 
270 template <>
271 EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a) {
273 
274  return std::complex<float>(a.v[0], a.v[1]);
275 }
276 
277 template <>
278 EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) {
280 
281  return Packet2cf((Packet4f)__builtin_msa_shf_w((v4i32)a.v, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
282 }
283 
284 template <>
285 EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& a) {
287 
288  return Packet2cf((Packet4f)__builtin_msa_shf_w((v4i32)a.v, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
289 }
290 
291 template <>
292 EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a) {
294 
296  value += a.v;
297  return std::complex<float>(value[0], value[1]);
298 }
299 
300 template <>
301 EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a) {
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 
309 
310 template <>
311 EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
313 
314  return a / b;
315 }
316 
317 inline 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 
322 EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2cf, 2>& kernel) {
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 
332 template <>
333 EIGEN_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 
341 struct 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  }
351  }
353  v = b.v;
354  return *this;
355  }
357  static const v2u64 p2ul_CONJ_XOR = { 0x0, 0x8000000000000000 };
358  return (Packet1cd)pxor(v, (Packet2d)p2ul_CONJ_XOR);
359  }
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  }
380  return Packet1cd(*this) *= b;
381  }
383  v = padd(v, b.v);
384  return *this;
385  }
387  return Packet1cd(*this) += b;
388  }
390  v = psub(v, b.v);
391  return *this;
392  }
394  return Packet1cd(*this) -= b;
395  }
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  }
404  return Packet1cd(*this) /= b;
405  }
407  return Packet1cd(pnegate(v));
408  }
409 
411 };
412 
413 inline std::ostream& operator<<(std::ostream& os, const Packet1cd& value) {
414  os << "[ (" << value.v[0] << ", " << value.v[1] << "i) ]";
415  return os;
416 }
417 
418 template <>
419 struct 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 
441 template <>
443  typedef std::complex<double> type;
445  typedef Packet1cd half;
446 };
447 
448 template <>
449 EIGEN_STRONG_INLINE Packet1cd pload<Packet1cd>(const std::complex<double>* from) {
451 
452  EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from));
453 }
454 
455 template <>
456 EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) {
458 
459  EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from));
460 }
461 
462 template <>
463 EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>& from) {
465 
466  return Packet1cd(from);
467 }
468 
469 template <>
472 
473  return a + b;
474 }
475 
476 template <>
479 
480  return a - b;
481 }
482 
483 template <>
486 
487  return -a;
488 }
489 
490 template <>
493 
494  return a.conjugate();
495 }
496 
497 template <>
500 
501  return a * b;
502 }
503 
504 template <>
507 
508  return Packet1cd(pand(a.v, b.v));
509 }
510 
511 template <>
514 
515  return Packet1cd(por(a.v, b.v));
516 }
517 
518 template <>
521 
522  return Packet1cd(pxor(a.v, b.v));
523 }
524 
525 template <>
528 
529  return Packet1cd(pandnot(a.v, b.v));
530 }
531 
532 template <>
533 EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) {
535 
536  return pset1<Packet1cd>(*from);
537 }
538 
539 template <>
540 EIGEN_STRONG_INLINE void pstore<std::complex<double> >(std::complex<double>* to,
541  const Packet1cd& from) {
543 
544  EIGEN_DEBUG_ALIGNED_STORE pstore<double>((double*)to, from.v);
545 }
546 
547 template <>
548 EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double>* to,
549  const Packet1cd& from) {
551 
552  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<double>((double*)to, from.v);
553 }
554 
555 template <>
556 EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double>* addr) {
558 
559  prefetch(reinterpret_cast<const double*>(addr));
560 }
561 
562 template <>
563 EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(
564  const std::complex<double>* from, Index stride __attribute__((unused))) {
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 
573 template <>
574 EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to,
575  const Packet1cd& from,
576  Index stride
577  __attribute__((unused))) {
579 
580  pstore(to, from);
581 }
582 
583 template <>
584 EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet1cd>(const Packet1cd& a) {
586 
587  return std::complex<double>(a.v[0], a.v[1]);
588 }
589 
590 template <>
593 
594  return a;
595 }
596 
597 template <>
598 EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) {
600 
601  return pfirst(a);
602 }
603 
604 template <>
605 EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) {
607 
608  return pfirst(a);
609 }
610 
612 
613 template <>
616 
617  return a / b;
618 }
619 
622 
623  return Packet1cd(preverse(Packet2d(x.v)));
624 }
625 
626 inline 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 
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
Eigen::internal::Packet2cf::v
Packet4f v
Definition: AltiVec/Complex.h:80
EIGEN_MSA_DEBUG
#define EIGEN_MSA_DEBUG
Definition: MSA/PacketMath.h:45
Eigen::internal::Packet2cf::Packet2cf
EIGEN_STRONG_INLINE Packet2cf(const std::complex< float > &a, const std::complex< float > &b)
Definition: MSA/Complex.h:26
Eigen::internal::ploadu< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf ploadu< Packet2cf >(const std::complex< float > *from)
Definition: AltiVec/Complex.h:124
Eigen::internal::Packet4i
__vector int Packet4i
Definition: AltiVec/PacketMath.h:31
Eigen::internal::Packet1cd::operator-
EIGEN_STRONG_INLINE Packet1cd operator-(void) const
Definition: MSA/Complex.h:406
EIGEN_DEVICE_FUNC
#define EIGEN_DEVICE_FUNC
Definition: Macros.h:976
Eigen::internal::Packet1cd::Packet1cd
EIGEN_STRONG_INLINE Packet1cd(const Packet1cd &a)
Definition: MSA/Complex.h:350
Eigen::internal::packet_traits::HasAbs
@ HasAbs
Definition: GenericPacketMath.h:121
Eigen
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
EIGEN_MAKE_CONJ_HELPER_CPLX_REAL
#define EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(PACKET_CPLX, PACKET_REAL)
Definition: ConjHelper.h:14
Eigen::internal::pmul< Packet2d >
EIGEN_STRONG_INLINE Packet2d pmul< Packet2d >(const Packet2d &a, const Packet2d &b)
Definition: MSA/PacketMath.h:916
Eigen::internal::unpacket_traits< Packet1cd >::half
Packet1cd half
Definition: MSA/Complex.h:445
Eigen::internal::packet_traits< std::complex< float > >::half
Packet2cf half
Definition: MSA/Complex.h:106
test_constructor::f1
auto f1
Definition: testHybridNonlinearFactor.cpp:56
Eigen::internal::packet_traits::HasSub
@ HasSub
Definition: GenericPacketMath.h:118
Eigen::internal::packet_traits::size
@ size
Definition: GenericPacketMath.h:112
Eigen::internal::Packet4f
__vector float Packet4f
Definition: AltiVec/PacketMath.h:30
s
RealScalar s
Definition: level1_cplx_impl.h:126
v0
static const double v0
Definition: testCal3DFisheye.cpp:31
Eigen::internal::pmul< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd pmul< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: MSA/Complex.h:498
Eigen::internal::Packet1cd::operator=
EIGEN_STRONG_INLINE Packet1cd & operator=(const Packet1cd &b)
Definition: MSA/Complex.h:352
Eigen::internal::PacketBlock
Definition: GenericPacketMath.h:1014
b
Scalar * b
Definition: benchVecAdd.cpp:17
Eigen::internal::pand< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf pand< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
Definition: AltiVec/Complex.h:169
Eigen::internal::predux_mul< Packet1cd >
EIGEN_STRONG_INLINE std::complex< double > predux_mul< Packet1cd >(const Packet1cd &a)
Definition: MSA/Complex.h:605
Eigen::internal::ploaddup< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf ploaddup< Packet2cf >(const std::complex< float > *from)
Definition: AltiVec/Complex.h:125
Eigen::internal::unpacket_traits< Packet1cd >::type
std::complex< double > type
Definition: MSA/Complex.h:443
Eigen::internal::pfirst
EIGEN_STRONG_INLINE bfloat16 pfirst(const Packet8bf &a)
Definition: AltiVec/PacketMath.h:1429
x
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
Definition: gnuplot_common_settings.hh:12
Eigen::internal::pcplxflip< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf pcplxflip< Packet2cf >(const Packet2cf &x)
Definition: AltiVec/Complex.h:219
Eigen::internal::Selector
Definition: GenericPacketMath.h:1027
Eigen::internal::__attribute__
svint32_t PacketXi __attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)))
Definition: SVE/PacketMath.h:33
Eigen::internal::predux< Packet2cf >
EIGEN_STRONG_INLINE std::complex< float > predux< Packet2cf >(const Packet2cf &a)
Definition: AltiVec/Complex.h:191
Eigen::internal::pandnot< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd pandnot< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: MSA/Complex.h:526
Eigen::internal::Packet2cf::Packet2cf
EIGEN_STRONG_INLINE Packet2cf(const Packet4f &a)
Definition: MSA/Complex.h:31
Eigen::internal::preverse
EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf &a)
Definition: AltiVec/Complex.h:184
Eigen::internal::PacketBlock::packet
Packet packet[N]
Definition: GenericPacketMath.h:1018
real
float real
Definition: datatypes.h:10
Eigen::internal::packet_traits::HasMin
@ HasMin
Definition: GenericPacketMath.h:123
Eigen::internal::packet_traits< std::complex< double > >::type
Packet1cd type
Definition: MSA/Complex.h:420
Eigen::internal::pdiv
EIGEN_DEVICE_FUNC Packet pdiv(const Packet &a, const Packet &b)
Definition: GenericPacketMath.h:244
Eigen::internal::ploadu< Packet2d >
EIGEN_STRONG_INLINE Packet2d ploadu< Packet2d >(const double *from)
Definition: MSA/PacketMath.h:1004
Eigen::internal::pconj
EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf &a)
Definition: AltiVec/Complex.h:167
res
cout<< "Here is the matrix m:"<< endl<< m<< endl;Matrix< ptrdiff_t, 3, 1 > res
Definition: PartialRedux_count.cpp:3
Eigen::internal::ploadu< Packet4f >
EIGEN_STRONG_INLINE Packet4f ploadu< Packet4f >(const float *from)
Definition: AltiVec/PacketMath.h:968
os
ofstream os("timeSchurFactors.csv")
Eigen::internal::unpacket_traits::vectorizable
@ vectorizable
Definition: GenericPacketMath.h:140
Eigen::internal::default_packet_traits::HasBlend
@ HasBlend
Definition: GenericPacketMath.h:60
Eigen::internal::pload< Packet4f >
EIGEN_STRONG_INLINE Packet4f pload< Packet4f >(const float *from)
Definition: AltiVec/PacketMath.h:443
Eigen::internal::Packet1cd::operator*=
EIGEN_STRONG_INLINE Packet1cd & operator*=(const Packet1cd &b)
Definition: MSA/Complex.h:360
Eigen::internal::ploadu< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd ploadu< Packet1cd >(const std::complex< double > *from)
Definition: MSA/Complex.h:456
Eigen::internal::unpacket_traits< Packet2cf >::type
std::complex< float > type
Definition: MSA/Complex.h:129
Eigen::internal::pxor
EIGEN_STRONG_INLINE Packet8h pxor(const Packet8h &a, const Packet8h &b)
Definition: AVX/PacketMath.h:1047
Eigen::internal::packet_traits::HasHalfPacket
@ HasHalfPacket
Definition: GenericPacketMath.h:114
Eigen::internal::Packet1cd::Packet1cd
EIGEN_STRONG_INLINE Packet1cd(const Packet2d &a)
Definition: MSA/Complex.h:348
EIGEN_DEBUG_UNALIGNED_STORE
#define EIGEN_DEBUG_UNALIGNED_STORE
Definition: GenericPacketMath.h:39
Eigen::internal::unpacket_traits::masked_store_available
@ masked_store_available
Definition: GenericPacketMath.h:142
Eigen::internal::pload< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd pload< Packet1cd >(const std::complex< double > *from)
Definition: MSA/Complex.h:449
Eigen::internal::padd< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd padd< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: MSA/Complex.h:470
Eigen::internal::por< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd por< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: MSA/Complex.h:512
Eigen::internal::unpacket_traits::size
@ size
Definition: GenericPacketMath.h:138
Eigen::internal::unpacket_traits::alignment
@ alignment
Definition: GenericPacketMath.h:139
Eigen::internal::Packet1cd::operator/
EIGEN_STRONG_INLINE Packet1cd operator/(const Packet1cd &b) const
Definition: MSA/Complex.h:403
Eigen::internal::pstore< double >
EIGEN_STRONG_INLINE void pstore< double >(double *to, const Packet4d &from)
Definition: AVX/PacketMath.h:623
Eigen::internal::Packet1cd::Packet1cd
EIGEN_STRONG_INLINE Packet1cd()
Definition: MSA/Complex.h:342
Eigen::internal::pfirst< Packet1cd >
EIGEN_STRONG_INLINE std::complex< double > pfirst< Packet1cd >(const Packet1cd &a)
Definition: MSA/Complex.h:584
Eigen::internal::Packet2cf::pmul
EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf &a, const Packet2cf &b)
Definition: AltiVec/Complex.h:35
test_constructor::f0
auto f0
Definition: testHybridNonlinearFactor.cpp:55
Eigen::internal::packet_traits< std::complex< float > >::type
Packet2cf type
Definition: MSA/Complex.h:105
Eigen::internal::pmul< Packet4f >
EIGEN_STRONG_INLINE Packet4f pmul< Packet4f >(const Packet4f &a, const Packet4f &b)
Definition: AltiVec/PacketMath.h:795
Eigen::internal::packet_traits::AlignedOnScalar
@ AlignedOnScalar
Definition: GenericPacketMath.h:113
Eigen::internal::pdiv< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd pdiv< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: MSA/Complex.h:614
Eigen::internal::psub< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd psub< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: MSA/Complex.h:477
Eigen::internal::Packet2cf::operator/
EIGEN_STRONG_INLINE Packet2cf operator/(const Packet2cf &b) const
Definition: MSA/Complex.h:85
Eigen::internal::Packet1cd::Packet1cd
EIGEN_STRONG_INLINE Packet1cd(const std::complex< double > &a)
Definition: MSA/Complex.h:344
Eigen::internal::padd< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf padd< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
Definition: AltiVec/Complex.h:164
Eigen::internal::pload< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf pload< Packet2cf >(const std::complex< float > *from)
Definition: AltiVec/Complex.h:123
Eigen::internal::pnegate
EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf &a)
Definition: AltiVec/Complex.h:166
Eigen::internal::Packet2cf::operator=
EIGEN_STRONG_INLINE Packet2cf & operator=(const Packet2cf &b)
Definition: MSA/Complex.h:35
Eigen::internal::pset1< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf pset1< Packet2cf >(const std::complex< float > &from)
Definition: AltiVec/Complex.h:112
Eigen::internal::unpacket_traits
Definition: GenericPacketMath.h:132
Eigen::internal::ptranspose
EIGEN_STRONG_INLINE void ptranspose(PacketBlock< Packet2cf, 2 > &kernel)
Definition: AltiVec/Complex.h:224
Eigen::internal::Packet2cf
Definition: AltiVec/Complex.h:30
Eigen::internal::pfirst< Packet2cf >
EIGEN_STRONG_INLINE std::complex< float > pfirst< Packet2cf >(const Packet2cf &a)
Definition: AltiVec/Complex.h:176
Eigen::internal::Packet2cf::operator+
EIGEN_STRONG_INLINE Packet2cf operator+(const Packet2cf &b) const
Definition: MSA/Complex.h:68
Eigen::internal::Packet1cd::operator-
EIGEN_STRONG_INLINE Packet1cd operator-(const Packet1cd &b) const
Definition: MSA/Complex.h:393
EIGEN_DEBUG_ALIGNED_LOAD
#define EIGEN_DEBUG_ALIGNED_LOAD
Definition: GenericPacketMath.h:27
EIGEN_STRONG_INLINE
#define EIGEN_STRONG_INLINE
Definition: Macros.h:917
Eigen::internal::pmul< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf pmul< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
Definition: MSA/Complex.h:173
Eigen::internal::pblend
EIGEN_STRONG_INLINE Packet4i pblend(const Selector< 4 > &ifPacket, const Packet4i &thenPacket, const Packet4i &elsePacket)
Definition: AltiVec/PacketMath.h:2107
Eigen::internal::pset1< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd pset1< Packet1cd >(const std::complex< double > &from)
Definition: MSA/Complex.h:463
Eigen::internal::Packet2cf::Packet2cf
EIGEN_STRONG_INLINE Packet2cf()
Definition: MSA/Complex.h:24
Eigen::internal::pand
EIGEN_STRONG_INLINE Packet8h pand(const Packet8h &a, const Packet8h &b)
Definition: AVX/PacketMath.h:1050
imag
const EIGEN_DEVICE_FUNC ImagReturnType imag() const
Definition: CommonCwiseUnaryOps.h:109
Eigen::internal::psub
EIGEN_DEVICE_FUNC Packet psub(const Packet &a, const Packet &b)
Definition: GenericPacketMath.h:222
Eigen::internal::Packet2cf::Packet2cf
EIGEN_STRONG_INLINE Packet2cf(const Packet2cf &a)
Definition: MSA/Complex.h:33
Eigen::internal::Packet1cd::v
Packet2d v
Definition: MSA/Complex.h:410
Eigen::internal::operator<<
std::ostream & operator<<(std::ostream &s, const Packet16c &v)
Definition: AltiVec/PacketMath.h:371
Eigen::internal::unpacket_traits< Packet2cf >::half
Packet2cf half
Definition: MSA/Complex.h:131
Eigen::internal::pstore
EIGEN_DEVICE_FUNC void pstore(Scalar *to, const Packet &from)
Definition: GenericPacketMath.h:696
Eigen::internal::por< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf por< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
Definition: AltiVec/Complex.h:170
Eigen::internal::unpacket_traits::masked_load_available
@ masked_load_available
Definition: GenericPacketMath.h:141
Eigen::internal::Packet1cd::operator/=
EIGEN_STRONG_INLINE Packet1cd & operator/=(const Packet1cd &b)
Definition: MSA/Complex.h:396
Eigen::internal::Packet1cd::operator-=
EIGEN_STRONG_INLINE Packet1cd & operator-=(const Packet1cd &b)
Definition: MSA/Complex.h:389
Eigen::Aligned16
@ Aligned16
Definition: Constants.h:235
Eigen::internal::prefetch
EIGEN_DEVICE_FUNC void prefetch(const Scalar *addr)
Definition: GenericPacketMath.h:719
a
ArrayXXi a
Definition: Array_initializer_list_23_cxx11.cpp:1
Eigen::internal::packet_traits::HasAbs2
@ HasAbs2
Definition: GenericPacketMath.h:122
Eigen::internal::Packet2cf::operator+=
EIGEN_STRONG_INLINE Packet2cf & operator+=(const Packet2cf &b)
Definition: MSA/Complex.h:64
Eigen::internal::Packet2cf::operator-=
EIGEN_STRONG_INLINE Packet2cf & operator-=(const Packet2cf &b)
Definition: MSA/Complex.h:71
Eigen::internal::packet_traits< std::complex< double > >::half
Packet1cd half
Definition: MSA/Complex.h:421
Eigen::internal::pmul
EIGEN_DEVICE_FUNC Packet pmul(const Packet &a, const Packet &b)
Definition: GenericPacketMath.h:237
Eigen::internal::Packet2d
v2f64 Packet2d
Definition: MSA/PacketMath.h:820
Eigen::internal::Packet1cd::operator+=
EIGEN_STRONG_INLINE Packet1cd & operator+=(const Packet1cd &b)
Definition: MSA/Complex.h:382
EIGEN_DEBUG_UNALIGNED_LOAD
#define EIGEN_DEBUG_UNALIGNED_LOAD
Definition: GenericPacketMath.h:31
Eigen::internal::Packet2cf::operator-
EIGEN_STRONG_INLINE Packet2cf operator-(void) const
Definition: MSA/Complex.h:88
Eigen::internal::Packet2cf::operator*=
EIGEN_STRONG_INLINE Packet2cf & operator*=(const Packet2cf &b)
Definition: MSA/Complex.h:42
std
Definition: BFloat16.h:88
Eigen::internal::pandnot< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf pandnot< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
Definition: AltiVec/Complex.h:172
v2
Vector v2
Definition: testSerializationBase.cpp:39
Eigen::internal::pstoreu< double >
EIGEN_STRONG_INLINE void pstoreu< double >(double *to, const Packet4d &from)
Definition: AVX/PacketMath.h:627
Eigen::internal::packet_traits::HasAdd
@ HasAdd
Definition: GenericPacketMath.h:117
Eigen::internal::pcplxflip
EIGEN_STRONG_INLINE Packet1cd pcplxflip(const Packet1cd &x)
Definition: MSA/Complex.h:620
Eigen::internal::packet_traits::HasMax
@ HasMax
Definition: GenericPacketMath.h:124
Eigen::internal::pxor< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd pxor< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: MSA/Complex.h:519
Eigen::internal::padd
EIGEN_DEVICE_FUNC Packet padd(const Packet &a, const Packet &b)
Definition: GenericPacketMath.h:215
Eigen::internal::psub< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf psub< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
Definition: AltiVec/Complex.h:165
Eigen::internal::ploaddup< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd ploaddup< Packet1cd >(const std::complex< double > *from)
Definition: MSA/Complex.h:533
Eigen::internal::packet_traits::HasNegate
@ HasNegate
Definition: GenericPacketMath.h:120
Eigen::internal::por
EIGEN_STRONG_INLINE Packet8h por(const Packet8h &a, const Packet8h &b)
Definition: AVX/PacketMath.h:1042
Eigen::internal::default_packet_traits::HasDiv
@ HasDiv
Definition: GenericPacketMath.h:65
Eigen::internal::Packet2cf::operator*
EIGEN_STRONG_INLINE Packet2cf operator*(const Packet2cf &b) const
Definition: MSA/Complex.h:61
Eigen::internal::pxor< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf pxor< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
Definition: AltiVec/Complex.h:171
internal
Definition: BandTriangularSolver.h:13
Eigen::internal::Packet1cd::operator*
EIGEN_STRONG_INLINE Packet1cd operator*(const Packet1cd &b) const
Definition: MSA/Complex.h:379
Eigen::internal::pstoreu< float >
EIGEN_STRONG_INLINE void pstoreu< float >(float *to, const Packet4f &from)
Definition: AltiVec/PacketMath.h:1088
EIGEN_MSA_SHF_I8
#define EIGEN_MSA_SHF_I8(a, b, c, d)
Definition: MSA/PacketMath.h:48
Eigen::internal::Packet2cf::operator/=
EIGEN_STRONG_INLINE Packet2cf & operator/=(const Packet2cf &b)
Definition: MSA/Complex.h:78
Eigen::internal::pand< Packet1cd >
EIGEN_STRONG_INLINE Packet1cd pand< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: MSA/Complex.h:505
align_3::t
Point2 t(10, 10)
Eigen::internal::pandnot
EIGEN_STRONG_INLINE Packet8h pandnot(const Packet8h &a, const Packet8h &b)
Definition: AVX/PacketMath.h:1053
Eigen::internal::predux_mul< Packet2cf >
EIGEN_STRONG_INLINE std::complex< float > predux_mul< Packet2cf >(const Packet2cf &a)
Definition: AltiVec/Complex.h:199
Eigen::internal::Packet1cd::operator+
EIGEN_STRONG_INLINE Packet1cd operator+(const Packet1cd &b) const
Definition: MSA/Complex.h:386
Eigen::internal::Packet1cd
Definition: MSA/Complex.h:341
Eigen::internal::packet_traits::HasMul
@ HasMul
Definition: GenericPacketMath.h:119
Eigen::internal::Packet2cf::conjugate
EIGEN_STRONG_INLINE Packet2cf conjugate(void) const
Definition: MSA/Complex.h:39
Eigen::internal::packet_traits::Vectorizable
@ Vectorizable
Definition: GenericPacketMath.h:111
test_callbacks.value
value
Definition: test_callbacks.py:160
Eigen::internal::pload< Packet2d >
EIGEN_STRONG_INLINE Packet2d pload< Packet2d >(const double *from)
Definition: MSA/PacketMath.h:967
EIGEN_DEBUG_ALIGNED_STORE
#define EIGEN_DEBUG_ALIGNED_STORE
Definition: GenericPacketMath.h:35
Eigen::internal::Packet1cd::conjugate
EIGEN_STRONG_INLINE Packet1cd conjugate(void) const
Definition: MSA/Complex.h:356
Eigen::internal::pstore< float >
EIGEN_STRONG_INLINE void pstore< float >(float *to, const Packet4f &from)
Definition: AltiVec/PacketMath.h:491
v1
Vector v1
Definition: testSerializationBase.cpp:38
complex
Definition: datatypes.h:12
Eigen::internal::packet_traits::HasSetLinear
@ HasSetLinear
Definition: GenericPacketMath.h:126
Eigen::internal::predux< Packet1cd >
EIGEN_STRONG_INLINE std::complex< double > predux< Packet1cd >(const Packet1cd &a)
Definition: MSA/Complex.h:598
Eigen::internal::pdiv< Packet2cf >
EIGEN_STRONG_INLINE Packet2cf pdiv< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
Definition: AltiVec/Complex.h:211
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
Eigen::internal::Packet2cf::operator-
EIGEN_STRONG_INLINE Packet2cf operator-(const Packet2cf &b) const
Definition: MSA/Complex.h:75


gtsam
Author(s):
autogenerated on Fri Nov 1 2024 03:32:08