ZVector/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) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
5 // Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
6 //
7 // This Source Code Form is subject to the terms of the Mozilla
8 // Public License v. 2.0. If a copy of the MPL was not distributed
9 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10 
11 #ifndef EIGEN_COMPLEX32_ALTIVEC_H
12 #define EIGEN_COMPLEX32_ALTIVEC_H
13 
14 namespace Eigen {
15 
16 namespace internal {
17 
18 static Packet2ul p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_ZERO_, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
19 static Packet2ul p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO, (Packet4ui) p2d_ZERO_, 8);//{ 0x8000000000000000, 0x0000000000000000 };
20 
21 struct Packet1cd
22 {
24  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {}
26 };
27 
28 struct Packet2cf
29 {
31  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {}
32  union {
33  Packet4f v;
34  Packet1cd cd[2];
35  };
36 };
37 
38 template<> struct packet_traits<std::complex<float> > : default_packet_traits
39 {
40  typedef Packet2cf type;
41  typedef Packet2cf half;
42  enum {
43  Vectorizable = 1,
44  AlignedOnScalar = 1,
45  size = 2,
46  HasHalfPacket = 0,
47 
48  HasAdd = 1,
49  HasSub = 1,
50  HasMul = 1,
51  HasDiv = 1,
52  HasNegate = 1,
53  HasAbs = 0,
54  HasAbs2 = 0,
55  HasMin = 0,
56  HasMax = 0,
57  HasBlend = 1,
58  HasSetLinear = 0
59  };
60 };
61 
62 
63 template<> struct packet_traits<std::complex<double> > : default_packet_traits
64 {
65  typedef Packet1cd type;
66  typedef Packet1cd half;
67  enum {
68  Vectorizable = 1,
69  AlignedOnScalar = 1,
70  size = 1,
71  HasHalfPacket = 0,
72 
73  HasAdd = 1,
74  HasSub = 1,
75  HasMul = 1,
76  HasDiv = 1,
77  HasNegate = 1,
78  HasAbs = 0,
79  HasAbs2 = 0,
80  HasMin = 0,
81  HasMax = 0,
82  HasSetLinear = 0
83  };
84 };
85 
86 template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2, alignment=Aligned16}; typedef Packet2cf half; };
87 template<> struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1, alignment=Aligned16}; typedef Packet1cd half; };
88 
89 /* Forward declaration */
91 
92 template<> EIGEN_STRONG_INLINE Packet2cf pload <Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from)); }
93 template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); }
94 template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from)); }
95 template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); }
96 template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); }
97 template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> * to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }
98 template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); }
99 template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> * to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }
100 
101 template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>& from)
102 { /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
103 
104 template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>& from)
105 {
106  Packet2cf res;
107  res.cd[0] = Packet1cd(vec_ld2f((const float *)&from));
108  res.cd[1] = res.cd[0];
109  return res;
110 }
111 template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
112 {
113  std::complex<float> EIGEN_ALIGN16 af[2];
114  af[0] = from[0*stride];
115  af[1] = from[1*stride];
116  return pload<Packet2cf>(af);
117 }
118 template<> EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(const std::complex<double>* from, Index stride EIGEN_UNUSED)
119 {
120  return pload<Packet1cd>(from);
121 }
122 template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
123 {
124  std::complex<float> EIGEN_ALIGN16 af[2];
125  pstore<std::complex<float> >((std::complex<float> *) af, from);
126  to[0*stride] = af[0];
127  to[1*stride] = af[1];
128 }
129 template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to, const Packet1cd& from, Index stride EIGEN_UNUSED)
130 {
131  pstore<std::complex<double> >(to, from);
132 }
133 
134 template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(padd<Packet4f>(a.v, b.v)); }
135 template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v + b.v); }
136 template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(psub<Packet4f>(a.v, b.v)); }
137 template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v - b.v); }
138 template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2d(a.v))); }
139 template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(Packet4f(a.v))); }
140 template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) { return Packet1cd((Packet2d)vec_xor((Packet2d)a.v, (Packet2d)p2ul_CONJ_XOR2)); }
141 template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a)
142 {
143  Packet2cf res;
144  res.v.v4f[0] = pconj(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[0]))).v;
145  res.v.v4f[1] = pconj(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[1]))).v;
146  return res;
147 }
148 
150 {
151  Packet2d a_re, a_im, v1, v2;
152 
153  // Permute and multiply the real parts of a and b
154  a_re = vec_perm(a.v, a.v, p16uc_PSET64_HI);
155  // Get the imaginary parts of a
156  a_im = vec_perm(a.v, a.v, p16uc_PSET64_LO);
157  // multiply a_re * b
158  v1 = vec_madd(a_re, b.v, p2d_ZERO);
159  // multiply a_im * b and get the conjugate result
160  v2 = vec_madd(a_im, b.v, p2d_ZERO);
161  v2 = (Packet2d) vec_sld((Packet4ui)v2, (Packet4ui)v2, 8);
162  v2 = (Packet2d) vec_xor((Packet2d)v2, (Packet2d) p2ul_CONJ_XOR1);
163 
164  return Packet1cd(v1 + v2);
165 }
167 {
168  Packet2cf res;
169  res.v.v4f[0] = pmul(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[0])), Packet1cd(reinterpret_cast<Packet2d>(b.v.v4f[0]))).v;
170  res.v.v4f[1] = pmul(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[1])), Packet1cd(reinterpret_cast<Packet2d>(b.v.v4f[1]))).v;
171  return res;
172 }
173 
174 template<> EIGEN_STRONG_INLINE Packet1cd pand <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_and(a.v,b.v)); }
175 template<> EIGEN_STRONG_INLINE Packet2cf pand <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pand<Packet4f>(a.v,b.v)); }
176 template<> EIGEN_STRONG_INLINE Packet1cd por <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_or(a.v,b.v)); }
177 template<> EIGEN_STRONG_INLINE Packet2cf por <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(por<Packet4f>(a.v,b.v)); }
178 template<> EIGEN_STRONG_INLINE Packet1cd pxor <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_xor(a.v,b.v)); }
179 template<> EIGEN_STRONG_INLINE Packet2cf pxor <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pxor<Packet4f>(a.v,b.v)); }
180 template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_and(a.v, vec_nor(b.v,b.v))); }
181 template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pandnot<Packet4f>(a.v,b.v)); }
182 
183 template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) { return pset1<Packet1cd>(*from); }
184 template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from) { return pset1<Packet2cf>(*from); }
185 
186 template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> * addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
187 template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> * addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
188 
189 template<> EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet1cd>(const Packet1cd& a)
190 {
191  std::complex<double> EIGEN_ALIGN16 res;
192  pstore<std::complex<double> >(&res, a);
193 
194  return res;
195 }
196 template<> EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a)
197 {
198  std::complex<float> EIGEN_ALIGN16 res[2];
199  pstore<std::complex<float> >(res, a);
200 
201  return res[0];
202 }
203 
204 template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
205 template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
206 {
207  Packet2cf res;
208  res.cd[0] = a.cd[1];
209  res.cd[1] = a.cd[0];
210  return res;
211 }
212 
213 template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a)
214 {
215  return pfirst(a);
216 }
217 template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
218 {
219  std::complex<float> res;
220  Packet1cd b = padd<Packet1cd>(a.cd[0], a.cd[1]);
221  vec_st2f(b.v, (float*)&res);
222  return res;
223 }
224 
226 {
227  return vecs[0];
228 }
230 {
231  PacketBlock<Packet2cf,2> transpose;
232  transpose.packet[0] = vecs[0];
233  transpose.packet[1] = vecs[1];
234  ptranspose(transpose);
235 
236  return padd<Packet2cf>(transpose.packet[0], transpose.packet[1]);
237 }
238 
239 template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a)
240 {
241  return pfirst(a);
242 }
243 template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
244 {
245  std::complex<float> res;
246  Packet1cd b = pmul<Packet1cd>(a.cd[0], a.cd[1]);
247  vec_st2f(b.v, (float*)&res);
248  return res;
249 }
250 
251 template<int Offset>
252 struct palign_impl<Offset,Packet1cd>
253 {
254  static EIGEN_STRONG_INLINE void run(Packet1cd& /*first*/, const Packet1cd& /*second*/)
255  {
256  // FIXME is it sure we never have to align a Packet1cd?
257  // Even though a std::complex<double> has 16 bytes, it is not necessarily aligned on a 16 bytes boundary...
258  }
259 };
260 
261 template<int Offset>
262 struct palign_impl<Offset,Packet2cf>
263 {
264  static EIGEN_STRONG_INLINE void run(Packet2cf& first, const Packet2cf& second)
265  {
266  if (Offset == 1) {
267  first.cd[0] = first.cd[1];
268  first.cd[1] = second.cd[0];
269  }
270  }
271 };
272 
273 template<> struct conj_helper<Packet1cd, Packet1cd, false,true>
274 {
275  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
276  { return padd(pmul(x,y),c); }
277 
278  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
279  {
280  return internal::pmul(a, pconj(b));
281  }
282 };
283 
284 template<> struct conj_helper<Packet1cd, Packet1cd, true,false>
285 {
286  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
287  { return padd(pmul(x,y),c); }
288 
289  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
290  {
291  return internal::pmul(pconj(a), b);
292  }
293 };
294 
295 template<> struct conj_helper<Packet1cd, Packet1cd, true,true>
296 {
297  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
298  { return padd(pmul(x,y),c); }
299 
300  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
301  {
302  return pconj(internal::pmul(a, b));
303  }
304 };
305 
306 template<> struct conj_helper<Packet2cf, Packet2cf, false,true>
307 {
308  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
309  { return padd(pmul(x,y),c); }
310 
311  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
312  {
313  return internal::pmul(a, pconj(b));
314  }
315 };
316 
317 template<> struct conj_helper<Packet2cf, Packet2cf, true,false>
318 {
319  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
320  { return padd(pmul(x,y),c); }
321 
322  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
323  {
324  return internal::pmul(pconj(a), b);
325  }
326 };
327 
328 template<> struct conj_helper<Packet2cf, Packet2cf, true,true>
329 {
330  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
331  { return padd(pmul(x,y),c); }
332 
333  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
334  {
335  return pconj(internal::pmul(a, b));
336  }
337 };
338 
341 
342 template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
343 {
344  // TODO optimize it for AltiVec
346  Packet2d s = vec_madd(b.v, b.v, p2d_ZERO_);
347  return Packet1cd(pdiv(res.v, s + vec_perm(s, s, p16uc_REVERSE64)));
348 }
349 
350 template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
351 {
352  // TODO optimize it for AltiVec
353  Packet2cf res;
354  res.cd[0] = pdiv<Packet1cd>(a.cd[0], b.cd[0]);
355  res.cd[1] = pdiv<Packet1cd>(a.cd[1], b.cd[1]);
356  return res;
357 }
358 
359 EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
360 {
361  return Packet1cd(preverse(Packet2d(x.v)));
362 }
363 
364 EIGEN_STRONG_INLINE Packet2cf pcplxflip/*<Packet2cf>*/(const Packet2cf& x)
365 {
366  Packet2cf res;
367  res.cd[0] = pcplxflip(x.cd[0]);
368  res.cd[1] = pcplxflip(x.cd[1]);
369  return res;
370 }
371 
373 {
374  Packet2d tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
375  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
376  kernel.packet[0].v = tmp;
377 }
378 
380 {
381  Packet1cd tmp = kernel.packet[0].cd[1];
382  kernel.packet[0].cd[1] = kernel.packet[1].cd[0];
383  kernel.packet[1].cd[0] = tmp;
384 }
385 
386 template<> EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
387  Packet2cf result;
388  const Selector<4> ifPacket4 = { ifPacket.select[0], ifPacket.select[0], ifPacket.select[1], ifPacket.select[1] };
389  result.v = pblend<Packet4f>(ifPacket4, thenPacket.v, elsePacket.v);
390  return result;
391 }
392 
393 } // end namespace internal
394 
395 } // end namespace Eigen
396 
397 #endif // EIGEN_COMPLEX32_ALTIVEC_H
static Packet16uc p16uc_REVERSE64
EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf &a, const Packet2cf &b) const
static EIGEN_STRONG_INLINE void run(Packet1cd &, const Packet1cd &)
EIGEN_STRONG_INLINE Packet1cd ploaddup< Packet1cd >(const std::complex< double > *from)
Definition: SSE/Complex.h:321
EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd &a, const Packet1cd &b) const
EIGEN_STRONG_INLINE Packet4f pxor< Packet4f >(const Packet4f &a, const Packet4f &b)
#define EIGEN_STRONG_INLINE
Definition: Macros.h:494
__vector float Packet4f
Vector v2
Scalar * b
Definition: benchVecAdd.cpp:17
EIGEN_STRONG_INLINE Packet2cf por< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
static Packet2d p2d_ZERO_
Vector v1
#define EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(PACKET_CPLX, PACKET_REAL)
Definition: ConjHelper.h:14
EIGEN_STRONG_INLINE Packet2cf preduxp< Packet2cf >(const Packet2cf *vecs)
EIGEN_STRONG_INLINE Packet1cd padd< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: SSE/Complex.h:285
EIGEN_STRONG_INLINE Packet1cd preduxp< Packet1cd >(const Packet1cd *vecs)
Definition: SSE/Complex.h:343
#define EIGEN_DEBUG_UNALIGNED_LOAD
EIGEN_STRONG_INLINE Packet2cf pmul< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
static Packet16uc p16uc_TRANSPOSE64_LO
Scalar Scalar * c
Definition: benchVecAdd.cpp:17
EIGEN_STRONG_INLINE Packet1cd pand< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: SSE/Complex.h:308
EIGEN_STRONG_INLINE Packet2cf ploadu< Packet2cf >(const std::complex< float > *from)
#define EIGEN_DEBUG_ALIGNED_STORE
__vector unsigned int Packet4ui
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf &x, const Packet2cf &y, const Packet2cf &c) const
EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf &x, const Packet2cf &y, const Packet2cf &c) const
Definition: Half.h:150
EIGEN_STRONG_INLINE Packet1cd()
EIGEN_STRONG_INLINE Packet1cd pdiv< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: SSE/Complex.h:419
EIGEN_STRONG_INLINE Packet2cf pload< Packet2cf >(const std::complex< float > *from)
EIGEN_STRONG_INLINE Packet2cf pset1< Packet2cf >(const std::complex< float > &from)
EIGEN_STRONG_INLINE Packet1cd pxor< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: SSE/Complex.h:310
EIGEN_STRONG_INLINE std::complex< float > pfirst< Packet2cf >(const Packet2cf &a)
#define EIGEN_DEBUG_UNALIGNED_STORE
EIGEN_STRONG_INLINE Packet1cd pset1< Packet1cd >(const std::complex< double > &from)
Definition: SSE/Complex.h:318
#define EIGEN_DEBUG_ALIGNED_LOAD
EIGEN_STRONG_INLINE Packet2cf pcplxflip(const Packet2cf &x)
Definition: SSE/Complex.h:242
EIGEN_STRONG_INLINE Packet2cf psub< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
Array33i a
#define EIGEN_ZVECTOR_PREFETCH(ADDR)
EIGEN_DEVICE_FUNC Packet padd(const Packet &a, const Packet &b)
cout<< "Here is the matrix m:"<< endl<< m<< endl;Matrix< ptrdiff_t, 3, 1 > res
EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd &a, const Packet1cd &b) const
#define EIGEN_UNUSED
Definition: Macros.h:609
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf &a, const Packet2cf &b) const
EIGEN_STRONG_INLINE Packet2cf(const Packet4f &a)
EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf &x, const Packet2cf &y, const Packet2cf &c) const
EIGEN_STRONG_INLINE std::complex< double > predux< Packet1cd >(const Packet1cd &a)
Definition: SSE/Complex.h:338
EIGEN_DEVICE_FUNC void pstoreu(Scalar *to, const Packet &from)
EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd &x, const Packet1cd &y, const Packet1cd &c) const
constexpr int first(int i)
Implementation details for constexpr functions.
Values result
EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd &x, const Packet1cd &y, const Packet1cd &c) const
EIGEN_STRONG_INLINE Packet1cd(const Packet2d &a)
__vector unsigned long long Packet2ul
EIGEN_STRONG_INLINE Packet4f ploadu< Packet4f >(const float *from)
EIGEN_STRONG_INLINE void ptranspose(PacketBlock< Packet2cf, 2 > &kernel)
EIGEN_STRONG_INLINE Packet2cf pand< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
EIGEN_STRONG_INLINE Packet2cf()
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
EIGEN_STRONG_INLINE Packet4f por< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet1cd pandnot< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: SSE/Complex.h:311
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type pfirst(const Packet &a)
EIGEN_STRONG_INLINE Packet1cd pload< Packet1cd >(const std::complex< double > *from)
Definition: SSE/Complex.h:314
RealScalar s
EIGEN_STRONG_INLINE Packet4f pandnot< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE std::complex< float > predux_mul< Packet2cf >(const Packet2cf &a)
EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd &a, const Packet1cd &b) const
EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf &a, const Packet2cf &b) const
EIGEN_STRONG_INLINE Packet2d ploadu< Packet2d >(const double *from)
EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf &a)
EIGEN_STRONG_INLINE Packet2d pload< Packet2d >(const double *from)
EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd &x, const Packet1cd &y, const Packet1cd &c) const
EIGEN_STRONG_INLINE std::complex< float > predux< Packet2cf >(const Packet2cf &a)
EIGEN_STRONG_INLINE Packet2cf ploaddup< Packet2cf >(const std::complex< float > *from)
EIGEN_STRONG_INLINE std::complex< double > predux_mul< Packet1cd >(const Packet1cd &a)
Definition: SSE/Complex.h:348
EIGEN_DEVICE_FUNC void pstore(Scalar *to, const Packet &from)
EIGEN_STRONG_INLINE Packet4f pload< Packet4f >(const float *from)
#define EIGEN_ALIGN16
Definition: Macros.h:753
EIGEN_STRONG_INLINE Packet1cd psub< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: SSE/Complex.h:286
EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf &a)
EIGEN_DEVICE_FUNC Packet pdiv(const Packet &a, const Packet &b)
static EIGEN_STRONG_INLINE void run(Packet2cf &first, const Packet2cf &second)
EIGEN_STRONG_INLINE Packet4f padd< Packet4f >(const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet1cd pmul< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: SSE/Complex.h:294
EIGEN_STRONG_INLINE Packet1cd ploadu< Packet1cd >(const std::complex< double > *from)
Definition: SSE/Complex.h:316
EIGEN_STRONG_INLINE Packet1cd por< Packet1cd >(const Packet1cd &a, const Packet1cd &b)
Definition: SSE/Complex.h:309
EIGEN_STRONG_INLINE Packet2cf pxor< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
static Packet2ul p2ul_CONJ_XOR1
EIGEN_STRONG_INLINE Packet2cf padd< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
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
static Packet16uc p16uc_PSET64_HI
EIGEN_DEVICE_FUNC Packet pmul(const Packet &a, const Packet &b)
static Packet16uc p16uc_TRANSPOSE64_HI
EIGEN_STRONG_INLINE Packet4f psub< Packet4f >(const Packet4f &a, const Packet4f &b)
static Packet16uc p16uc_PSET64_LO
EIGEN_STRONG_INLINE Packet2cf pandnot< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
EIGEN_STRONG_INLINE Packet4i pblend(const Selector< 4 > &ifPacket, const Packet4i &thenPacket, const Packet4i &elsePacket)
EIGEN_STRONG_INLINE std::complex< double > pfirst< Packet1cd >(const Packet1cd &a)
Definition: SSE/Complex.h:329
EIGEN_STRONG_INLINE Packet2cf pdiv< Packet2cf >(const Packet2cf &a, const Packet2cf &b)
EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf &a)
static Packet2ul p2ul_CONJ_XOR2
EIGEN_STRONG_INLINE Packet4f pand< Packet4f >(const Packet4f &a, const Packet4f &b)


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:41:49