ROOT  6.07/01
Reference Guide
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
vector.h
Go to the documentation of this file.
1 /* This file is part of the Vc library.
2 
3  Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
4 
5  Vc is free software: you can redistribute it and/or modify
6  it under the terms of the GNU Lesser General Public License as
7  published by the Free Software Foundation, either version 3 of
8  the License, or (at your option) any later version.
9 
10  Vc is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  GNU Lesser General Public License for more details.
14 
15  You should have received a copy of the GNU Lesser General Public
16  License along with Vc. If not, see <http://www.gnu.org/licenses/>.
17 
18 */
19 
20 #ifndef SSE_VECTOR_H
21 #define SSE_VECTOR_H
22 
23 #include "intrinsics.h"
24 #include "types.h"
25 #include "vectorhelper.h"
26 #include "mask.h"
27 #include "../common/aliasingentryhelper.h"
28 #include "../common/memoryfwd.h"
29 #include <algorithm>
30 #include <cmath>
31 
32 #include "macros.h"
33 
34 #ifdef isfinite
35 #undef isfinite
36 #endif
37 #ifdef isnan
38 #undef isnan
39 #endif
40 
41 namespace ROOT {
42 namespace Vc
43 {
44 namespace SSE
45 {
46 template<typename T>
47 class WriteMaskedVector
48 {
49  friend class Vector<T>;
50  typedef typename VectorTraits<T>::MaskType Mask;
51  typedef typename Vector<T>::EntryType EntryType;
52  public:
53  FREE_STORE_OPERATORS_ALIGNED(16)
54  //prefix
55  Vc_INTRINSIC Vector<T> &operator++() {
56  vec->data() = VectorHelper<T>::add(vec->data(),
57  VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
58  );
59  return *vec;
60  }
61  Vc_INTRINSIC Vector<T> &operator--() {
62  vec->data() = VectorHelper<T>::sub(vec->data(),
63  VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
64  );
65  return *vec;
66  }
67  //postfix
68  Vc_INTRINSIC Vector<T> operator++(int) {
69  Vector<T> ret(*vec);
70  vec->data() = VectorHelper<T>::add(vec->data(),
71  VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
72  );
73  return ret;
74  }
75  Vc_INTRINSIC Vector<T> operator--(int) {
76  Vector<T> ret(*vec);
77  vec->data() = VectorHelper<T>::sub(vec->data(),
78  VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
79  );
80  return ret;
81  }
82 
83  Vc_INTRINSIC Vector<T> &operator+=(const Vector<T> &x) {
84  vec->data() = VectorHelper<T>::add(vec->data(), VectorHelper<T>::notMaskedToZero(x.data(), mask.data()));
85  return *vec;
86  }
87  Vc_INTRINSIC Vector<T> &operator-=(const Vector<T> &x) {
88  vec->data() = VectorHelper<T>::sub(vec->data(), VectorHelper<T>::notMaskedToZero(x.data(), mask.data()));
89  return *vec;
90  }
91  Vc_INTRINSIC Vector<T> &operator*=(const Vector<T> &x) {
92  vec->assign(VectorHelper<T>::mul(vec->data(), x.data()), mask);
93  return *vec;
94  }
95  Vc_INTRINSIC Vector<T> &operator/=(const Vector<T> &x);
96 
97  Vc_INTRINSIC Vector<T> &operator+=(EntryType x) {
98  return operator+=(Vector<T>(x));
99  }
100  Vc_INTRINSIC Vector<T> &operator-=(EntryType x) {
101  return operator-=(Vector<T>(x));
102  }
103  Vc_INTRINSIC Vector<T> &operator*=(EntryType x) {
104  return operator*=(Vector<T>(x));
105  }
106  Vc_INTRINSIC Vector<T> &operator/=(EntryType x) {
107  return operator/=(Vector<T>(x));
108  }
109 
110  Vc_INTRINSIC Vector<T> &operator=(const Vector<T> &x) {
111  vec->assign(x, mask);
112  return *vec;
113  }
114 
115  Vc_INTRINSIC Vector<T> &operator=(EntryType x) {
116  vec->assign(Vector<T>(x), mask);
117  return *vec;
118  }
119 
120  template<typename F> Vc_INTRINSIC void call(const F &f) const {
121  return vec->call(f, mask);
122  }
123  template<typename F> Vc_INTRINSIC void call(F &f) const {
124  return vec->call(f, mask);
125  }
126  template<typename F> Vc_INTRINSIC Vector<T> apply(const F &f) const {
127  return vec->apply(f, mask);
128  }
129  template<typename F> Vc_INTRINSIC Vector<T> apply(F &f) const {
130  return vec->apply(f, mask);
131  }
132 
133  private:
134  Vc_ALWAYS_INLINE WriteMaskedVector(Vector<T> *v, const Mask &k) : vec(v), mask(k) {}
135  Vector<T> *const vec;
136  Mask mask;
137 };
138 
139 template<typename T> class Vector
140 {
141  friend class WriteMaskedVector<T>;
142  protected:
143 #ifdef VC_COMPILE_BENCHMARKS
144  public:
145 #endif
146  typedef typename VectorTraits<T>::StorageType StorageType;
147  StorageType d;
148  typedef typename VectorTraits<T>::GatherMaskType GatherMask;
149  typedef VectorHelper<typename VectorTraits<T>::VectorType> HV;
150  typedef VectorHelper<T> HT;
151  public:
152  FREE_STORE_OPERATORS_ALIGNED(16)
153 
154  enum Constants { Size = VectorTraits<T>::Size };
155  typedef typename VectorTraits<T>::VectorType VectorType;
156  typedef typename VectorTraits<T>::EntryType EntryType;
157  typedef typename VectorTraits<T>::IndexType IndexType;
158  typedef typename VectorTraits<T>::MaskType Mask;
159  typedef typename Mask::Argument MaskArg;
160  typedef Vc::Memory<Vector<T>, Size> Memory;
161 #ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
162  typedef const Vector<T> &AsArg;
163 #else
164  typedef const Vector<T> AsArg;
165 #endif
166 
167  typedef T _T;
168 
169  ///////////////////////////////////////////////////////////////////////////////////////////
170  // uninitialized
171  Vc_ALWAYS_INLINE Vector() {}
172 
173  ///////////////////////////////////////////////////////////////////////////////////////////
174  // constants
175  explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerZero::ZEnum) Vc_INTRINSIC_R;
176  explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerOne::OEnum) Vc_INTRINSIC_R;
177  explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerIndexesFromZero::IEnum) Vc_INTRINSIC_R;
178  static Vc_INTRINSIC_L Vector Zero() Vc_INTRINSIC_R;
179  static Vc_INTRINSIC_L Vector One() Vc_INTRINSIC_R;
180  static Vc_INTRINSIC_L Vector IndexesFromZero() Vc_INTRINSIC_R;
181  static Vc_INTRINSIC_L Vector Random() Vc_INTRINSIC_R;
182 
183  ///////////////////////////////////////////////////////////////////////////////////////////
184  // internal: required to enable returning objects of VectorType
185  Vc_ALWAYS_INLINE Vector(const VectorType &x) : d(x) {}
186 
187  ///////////////////////////////////////////////////////////////////////////////////////////
188  // static_cast / copy ctor
189  template<typename OtherT> explicit Vc_INTRINSIC_L Vector(const Vector<OtherT> &x) Vc_INTRINSIC_R;
190 
191  // implicit cast
192  template<typename OtherT> Vc_INTRINSIC_L Vector &operator=(const Vector<OtherT> &x) Vc_INTRINSIC_R;
193 
194  // copy assignment
195  Vc_ALWAYS_INLINE Vector &operator=(AsArg v) { d.v() = v.d.v(); return *this; }
196 
197  ///////////////////////////////////////////////////////////////////////////////////////////
198  // broadcast
199  explicit Vc_INTRINSIC_L Vector(EntryType a) Vc_INTRINSIC_R;
200  template<typename TT> Vc_INTRINSIC Vector(TT x, VC_EXACT_TYPE(TT, EntryType, void *) = 0) : d(HT::set(x)) {}
201  static Vc_INTRINSIC Vector broadcast4(const EntryType *x) { return Vector<T>(x); }
202  Vc_ALWAYS_INLINE Vector &operator=(EntryType a) { d.v() = HT::set(a); return *this; }
203 
204  ///////////////////////////////////////////////////////////////////////////////////////////
205  // load ctors
206  explicit Vc_INTRINSIC_L
207  Vector(const EntryType *x) Vc_INTRINSIC_R;
208  template<typename Alignment> Vc_INTRINSIC_L
209  Vector(const EntryType *x, Alignment align) Vc_INTRINSIC_R;
210  template<typename OtherT> explicit Vc_INTRINSIC_L
211  Vector(const OtherT *x) Vc_INTRINSIC_R;
212  template<typename OtherT, typename Alignment> Vc_INTRINSIC_L
213  Vector(const OtherT *x, Alignment align) Vc_INTRINSIC_R;
214 
215  ///////////////////////////////////////////////////////////////////////////////////////////
216  // load member functions
217  Vc_INTRINSIC_L
218  void load(const EntryType *mem) Vc_INTRINSIC_R;
219  template<typename Alignment> Vc_INTRINSIC_L
220  void load(const EntryType *mem, Alignment align) Vc_INTRINSIC_R;
221  template<typename OtherT> Vc_INTRINSIC_L
222  void load(const OtherT *mem) Vc_INTRINSIC_R;
223  template<typename OtherT, typename Alignment> Vc_INTRINSIC_L
224  void load(const OtherT *mem, Alignment align) Vc_INTRINSIC_R;
225 
226  ///////////////////////////////////////////////////////////////////////////////////////////
227  // expand 1 float_v to 2 double_v XXX rationale? remove it for release? XXX
228  explicit Vc_INTRINSIC_L Vector(const Vector<typename CtorTypeHelper<T>::Type> *a) Vc_INTRINSIC_R;
229  inline void expand(Vector<typename ExpandTypeHelper<T>::Type> *x) const;
230 
231  ///////////////////////////////////////////////////////////////////////////////////////////
232  // zeroing
233  Vc_INTRINSIC_L void setZero() Vc_INTRINSIC_R;
234  Vc_INTRINSIC_L void setZero(const Mask &k) Vc_INTRINSIC_R;
235 
236  Vc_INTRINSIC_L void setQnan() Vc_INTRINSIC_R;
237  Vc_INTRINSIC_L void setQnan(typename Mask::Argument k) Vc_INTRINSIC_R;
238 
239  ///////////////////////////////////////////////////////////////////////////////////////////
240  // stores
241  Vc_INTRINSIC_L void store(EntryType *mem) const Vc_INTRINSIC_R;
242  Vc_INTRINSIC_L void store(EntryType *mem, const Mask &mask) const Vc_INTRINSIC_R;
243  template<typename A> Vc_INTRINSIC_L void store(EntryType *mem, A align) const Vc_INTRINSIC_R;
244  template<typename A> Vc_INTRINSIC_L void store(EntryType *mem, const Mask &mask, A align) const Vc_INTRINSIC_R;
245 
246  ///////////////////////////////////////////////////////////////////////////////////////////
247  // swizzles
248  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> &abcd() const Vc_INTRINSIC_R Vc_PURE_R;
249  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> cdab() const Vc_INTRINSIC_R Vc_PURE_R;
250  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> badc() const Vc_INTRINSIC_R Vc_PURE_R;
251  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> aaaa() const Vc_INTRINSIC_R Vc_PURE_R;
252  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> bbbb() const Vc_INTRINSIC_R Vc_PURE_R;
253  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> cccc() const Vc_INTRINSIC_R Vc_PURE_R;
254  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> dddd() const Vc_INTRINSIC_R Vc_PURE_R;
255  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> bcad() const Vc_INTRINSIC_R Vc_PURE_R;
256  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> bcda() const Vc_INTRINSIC_R Vc_PURE_R;
257  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> dabc() const Vc_INTRINSIC_R Vc_PURE_R;
258  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> acbd() const Vc_INTRINSIC_R Vc_PURE_R;
259  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> dbca() const Vc_INTRINSIC_R Vc_PURE_R;
260  Vc_INTRINSIC_L Vc_PURE_L const Vector<T> dcba() const Vc_INTRINSIC_R Vc_PURE_R;
261 
262  ///////////////////////////////////////////////////////////////////////////////////////////
263  // gathers
264  template<typename IndexT> Vector(const EntryType *mem, const IndexT *indexes);
265  template<typename IndexT> Vector(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IndexT>) indexes);
266  template<typename IndexT> Vector(const EntryType *mem, const IndexT *indexes, MaskArg mask);
267  template<typename IndexT> Vector(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IndexT>) indexes, MaskArg mask);
268  template<typename S1, typename IT> Vector(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes);
269  template<typename S1, typename IT> Vector(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
270  template<typename S1, typename S2, typename IT> Vector(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes);
271  template<typename S1, typename S2, typename IT> Vector(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
272  template<typename S1, typename IT1, typename IT2> Vector(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes);
273  template<typename S1, typename IT1, typename IT2> Vector(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask);
274  template<typename Index> void gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes);
275  template<typename Index> void gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes, MaskArg mask);
276 #ifdef VC_USE_SET_GATHERS
277  template<typename IT> void gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IT>) indexes, MaskArg mask);
278 #endif
279  template<typename S1, typename IT> void gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes);
280  template<typename S1, typename IT> void gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
281  template<typename S1, typename S2, typename IT> void gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes);
282  template<typename S1, typename S2, typename IT> void gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
283  template<typename S1, typename IT1, typename IT2> void gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes);
284  template<typename S1, typename IT1, typename IT2> void gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask);
285 
286  ///////////////////////////////////////////////////////////////////////////////////////////
287  // scatters
288  template<typename Index> void scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes) const;
289  template<typename Index> void scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes, MaskArg mask) const;
290  template<typename S1, typename IT> void scatter(S1 *array, EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes) const;
291  template<typename S1, typename IT> void scatter(S1 *array, EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask) const;
292  template<typename S1, typename S2, typename IT> void scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes) const;
293  template<typename S1, typename S2, typename IT> void scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask) const;
294  template<typename S1, typename IT1, typename IT2> void scatter(S1 *array, EntryType *S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes) const;
295  template<typename S1, typename IT1, typename IT2> void scatter(S1 *array, EntryType *S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask) const;
296 
297  //prefix
298  Vc_INTRINSIC Vector &operator++() { data() = VectorHelper<T>::add(data(), VectorHelper<T>::one()); return *this; }
299  Vc_INTRINSIC Vector &operator--() { data() = VectorHelper<T>::sub(data(), VectorHelper<T>::one()); return *this; }
300  //postfix
301  Vc_INTRINSIC Vector operator++(int) { const Vector<T> r = *this; data() = VectorHelper<T>::add(data(), VectorHelper<T>::one()); return r; }
302  Vc_INTRINSIC Vector operator--(int) { const Vector<T> r = *this; data() = VectorHelper<T>::sub(data(), VectorHelper<T>::one()); return r; }
303 
304  Vc_INTRINSIC Common::AliasingEntryHelper<StorageType> operator[](size_t index) {
305 #if defined(VC_GCC) && VC_GCC >= 0x40300 && VC_GCC < 0x40400
306  ::ROOT::Vc::Warnings::_operator_bracket_warning();
307 #endif
308  return d.m(index);
309  }
310  Vc_INTRINSIC_L EntryType operator[](size_t index) const Vc_PURE Vc_INTRINSIC_R;
311 
312  Vc_INTRINSIC Vector Vc_PURE operator~() const { return VectorHelper<VectorType>::andnot_(data(), VectorHelper<VectorType>::allone()); }
313  Vc_ALWAYS_INLINE_L Vector<typename NegateTypeHelper<T>::Type> operator-() const Vc_ALWAYS_INLINE_R;
314  Vc_INTRINSIC Vector Vc_PURE operator+() const { return *this; }
315 
316 #define OP(symbol, fun) \
317  Vc_INTRINSIC Vector &operator symbol##=(const Vector<T> &x) { data() = VectorHelper<T>::fun(data(), x.data()); return *this; } \
318  Vc_INTRINSIC Vector &operator symbol##=(EntryType x) { return operator symbol##=(Vector<T>(x)); } \
319  Vc_INTRINSIC Vector Vc_PURE operator symbol(const Vector<T> &x) const { return HT::fun(data(), x.data()); } \
320  template<typename TT> Vc_INTRINSIC VC_EXACT_TYPE(TT, EntryType, Vector) Vc_PURE operator symbol(TT x) const { return operator symbol(Vector(x)); }
321 
322  OP(+, add)
323  OP(-, sub)
324  OP(*, mul)
325 #undef OP
326 
327  Vc_INTRINSIC_L Vector &operator<<=(AsArg shift) Vc_INTRINSIC_R;
328  Vc_INTRINSIC_L Vector operator<< (AsArg shift) const Vc_INTRINSIC_R;
329  Vc_INTRINSIC_L Vector &operator<<=( int shift) Vc_INTRINSIC_R;
330  Vc_INTRINSIC_L Vector operator<< ( int shift) const Vc_INTRINSIC_R;
331  Vc_INTRINSIC_L Vector &operator>>=(AsArg shift) Vc_INTRINSIC_R;
332  Vc_INTRINSIC_L Vector operator>> (AsArg shift) const Vc_INTRINSIC_R;
333  Vc_INTRINSIC_L Vector &operator>>=( int shift) Vc_INTRINSIC_R;
334  Vc_INTRINSIC_L Vector operator>> ( int shift) const Vc_INTRINSIC_R;
335 
336  Vc_INTRINSIC_L Vector &operator/=(const Vector<T> &x) Vc_INTRINSIC_R;
337  Vc_INTRINSIC_L Vector operator/ (const Vector<T> &x) const Vc_PURE Vc_INTRINSIC_R;
338  Vc_INTRINSIC_L Vector &operator/=(EntryType x) Vc_INTRINSIC_R;
339  template<typename TT> Vc_INTRINSIC_L VC_EXACT_TYPE(TT, typename DetermineEntryType<T>::Type, Vector<T>) operator/(TT x) const Vc_PURE Vc_INTRINSIC_R;
340 
341 #define OP(symbol, fun) \
342  Vc_INTRINSIC_L Vector &operator symbol##=(const Vector<T> &x) Vc_INTRINSIC_R; \
343  Vc_INTRINSIC_L Vector operator symbol(const Vector<T> &x) const Vc_PURE Vc_INTRINSIC_R; \
344  Vc_INTRINSIC Vector &operator symbol##=(EntryType x) { return operator symbol##=(Vector(x)); } \
345  template<typename TT> Vc_INTRINSIC VC_EXACT_TYPE(TT, EntryType, Vector) Vc_PURE operator symbol(TT x) const { return operator symbol(Vector(x)); }
346  OP(|, or_)
347  OP(&, and_)
348  OP(^, xor_)
349 #undef OP
350 #define OPcmp(symbol, fun) \
351  Vc_INTRINSIC Mask Vc_PURE operator symbol(const Vector<T> &x) const { return VectorHelper<T>::fun(data(), x.data()); } \
352  template<typename TT> Vc_INTRINSIC VC_EXACT_TYPE(TT, EntryType, Mask) Vc_PURE operator symbol(TT x) const { return operator symbol(Vector(x)); }
353 
354  OPcmp(==, cmpeq)
355  OPcmp(!=, cmpneq)
356  OPcmp(>=, cmpnlt)
357  OPcmp(>, cmpnle)
358  OPcmp(<, cmplt)
359  OPcmp(<=, cmple)
360 #undef OPcmp
361  Vc_INTRINSIC_L Vc_PURE_L Mask isNegative() const Vc_PURE_R Vc_INTRINSIC_R;
362 
363  Vc_ALWAYS_INLINE void fusedMultiplyAdd(const Vector<T> &factor, const Vector<T> &summand) {
364  VectorHelper<T>::fma(data(), factor.data(), summand.data());
365  }
366 
367  Vc_ALWAYS_INLINE void assign( const Vector<T> &v, const Mask &mask ) {
368  const VectorType k = mm128_reinterpret_cast<VectorType>(mask.data());
369  data() = VectorHelper<VectorType>::blend(data(), v.data(), k);
370  }
371 
372  template<typename V2> Vc_ALWAYS_INLINE Vc_PURE V2 staticCast() const { return StaticCastHelper<T, typename V2::_T>::cast(data()); }
373  template<typename V2> Vc_ALWAYS_INLINE Vc_PURE V2 reinterpretCast() const { return mm128_reinterpret_cast<typename V2::VectorType>(data()); }
374 
375  Vc_INTRINSIC WriteMaskedVector<T> operator()(const Mask &k) { return WriteMaskedVector<T>(this, k); }
376 
377  /**
378  * \return \p true This vector was completely filled. m2 might be 0 or != 0. You still have
379  * to test this.
380  * \p false This vector was not completely filled. m2 is all 0.
381  */
382  //inline bool pack(Mask &m1, Vector<T> &v2, Mask &m2) {
383  //return VectorHelper<T>::pack(data(), m1.data, v2.data(), m2.data);
384  //}
385 
386  Vc_ALWAYS_INLINE Vc_PURE VectorType &data() { return d.v(); }
387  Vc_ALWAYS_INLINE Vc_PURE const VectorType &data() const { return d.v(); }
388 
389  Vc_INTRINSIC EntryType min() const { return VectorHelper<T>::min(data()); }
390  Vc_INTRINSIC EntryType max() const { return VectorHelper<T>::max(data()); }
391  Vc_INTRINSIC EntryType product() const { return VectorHelper<T>::mul(data()); }
392  Vc_INTRINSIC EntryType sum() const { return VectorHelper<T>::add(data()); }
393  Vc_INTRINSIC_L EntryType min(MaskArg m) const Vc_INTRINSIC_R;
394  Vc_INTRINSIC_L EntryType max(MaskArg m) const Vc_INTRINSIC_R;
395  Vc_INTRINSIC_L EntryType product(MaskArg m) const Vc_INTRINSIC_R;
396  Vc_INTRINSIC_L EntryType sum(MaskArg m) const Vc_INTRINSIC_R;
397 
398  Vc_INTRINSIC_L Vector shifted(int amount) const Vc_INTRINSIC_R;
399  Vc_INTRINSIC_L Vector rotated(int amount) const Vc_INTRINSIC_R;
400  inline Vc_PURE Vector sorted() const { return SortHelper<VectorType, Size>::sort(data()); }
401 
402  template<typename F> void callWithValuesSorted(F &f) {
403  EntryType value = d.m(0);
404  f(value);
405  for (int i = 1; i < Size; ++i) {
406  if (d.m(i) != value) {
407  value = d.m(i);
408  f(value);
409  }
410  }
411  }
412 
413  template<typename F> Vc_INTRINSIC void call(const F &f) const {
414  for_all_vector_entries(i,
415  f(EntryType(d.m(i)));
416  );
417  }
418  template<typename F> Vc_INTRINSIC void call(F &f) const {
419  for_all_vector_entries(i,
420  f(EntryType(d.m(i)));
421  );
422  }
423 
424  template<typename F> Vc_INTRINSIC void call(const F &f, const Mask &mask) const {
425  Vc_foreach_bit(size_t i, mask) {
426  f(EntryType(d.m(i)));
427  }
428  }
429  template<typename F> Vc_INTRINSIC void call(F &f, const Mask &mask) const {
430  Vc_foreach_bit(size_t i, mask) {
431  f(EntryType(d.m(i)));
432  }
433  }
434 
435  template<typename F> Vc_INTRINSIC Vector<T> apply(const F &f) const {
436  Vector<T> r;
437  for_all_vector_entries(i,
438  r.d.m(i) = f(EntryType(d.m(i)));
439  );
440  return r;
441  }
442  template<typename F> Vc_INTRINSIC Vector<T> apply(F &f) const {
443  Vector<T> r;
444  for_all_vector_entries(i,
445  r.d.m(i) = f(EntryType(d.m(i)));
446  );
447  return r;
448  }
449 
450  template<typename F> Vc_INTRINSIC Vector<T> apply(const F &f, const Mask &mask) const {
451  Vector<T> r(*this);
452  Vc_foreach_bit (size_t i, mask) {
453  r.d.m(i) = f(EntryType(r.d.m(i)));
454  }
455  return r;
456  }
457  template<typename F> Vc_INTRINSIC Vector<T> apply(F &f, const Mask &mask) const {
458  Vector<T> r(*this);
459  Vc_foreach_bit (size_t i, mask) {
460  r.d.m(i) = f(EntryType(r.d.m(i)));
461  }
462  return r;
463  }
464 
465  template<typename IndexT> Vc_INTRINSIC void fill(EntryType (&f)(IndexT)) {
466  for_all_vector_entries(i,
467  d.m(i) = f(i);
468  );
469  }
470  Vc_INTRINSIC void fill(EntryType (&f)()) {
471  for_all_vector_entries(i,
472  d.m(i) = f();
473  );
474  }
475 
476  Vc_INTRINSIC_L Vector copySign(typename Vector::AsArg reference) const Vc_INTRINSIC_R;
477  Vc_INTRINSIC_L Vector exponent() const Vc_INTRINSIC_R;
478 };
479 
480 typedef Vector<double> double_v;
481 typedef Vector<float> float_v;
482 typedef Vector<float8> sfloat_v;
483 typedef Vector<int> int_v;
484 typedef Vector<unsigned int> uint_v;
485 typedef Vector<short> short_v;
486 typedef Vector<unsigned short> ushort_v;
487 typedef double_v::Mask double_m;
488 typedef float_v::Mask float_m;
489 typedef sfloat_v::Mask sfloat_m;
490 typedef int_v::Mask int_m;
491 typedef uint_v::Mask uint_m;
492 typedef short_v::Mask short_m;
493 typedef ushort_v::Mask ushort_m;
494 
495 template<> Vc_ALWAYS_INLINE Vc_PURE Vector<float8> Vector<float8>::broadcast4(const float *x) {
496  const _M128 &v = VectorHelper<_M128>::load(x, Aligned);
497  return Vector<float8>(M256::create(v, v));
498 }
499 
500 template<typename T> class SwizzledVector : public Vector<T> {};
501 
502 static Vc_ALWAYS_INLINE Vc_PURE int_v min(const int_v &x, const int_v &y) { return mm_min_epi32(x.data(), y.data()); }
503 static Vc_ALWAYS_INLINE Vc_PURE uint_v min(const uint_v &x, const uint_v &y) { return mm_min_epu32(x.data(), y.data()); }
504 static Vc_ALWAYS_INLINE Vc_PURE short_v min(const short_v &x, const short_v &y) { return _mm_min_epi16(x.data(), y.data()); }
505 static Vc_ALWAYS_INLINE Vc_PURE ushort_v min(const ushort_v &x, const ushort_v &y) { return mm_min_epu16(x.data(), y.data()); }
506 static Vc_ALWAYS_INLINE Vc_PURE float_v min(const float_v &x, const float_v &y) { return _mm_min_ps(x.data(), y.data()); }
507 static Vc_ALWAYS_INLINE Vc_PURE double_v min(const double_v &x, const double_v &y) { return _mm_min_pd(x.data(), y.data()); }
508 static Vc_ALWAYS_INLINE Vc_PURE int_v max(const int_v &x, const int_v &y) { return mm_max_epi32(x.data(), y.data()); }
509 static Vc_ALWAYS_INLINE Vc_PURE uint_v max(const uint_v &x, const uint_v &y) { return mm_max_epu32(x.data(), y.data()); }
510 static Vc_ALWAYS_INLINE Vc_PURE short_v max(const short_v &x, const short_v &y) { return _mm_max_epi16(x.data(), y.data()); }
511 static Vc_ALWAYS_INLINE Vc_PURE ushort_v max(const ushort_v &x, const ushort_v &y) { return mm_max_epu16(x.data(), y.data()); }
512 static Vc_ALWAYS_INLINE Vc_PURE float_v max(const float_v &x, const float_v &y) { return _mm_max_ps(x.data(), y.data()); }
513 static Vc_ALWAYS_INLINE Vc_PURE double_v max(const double_v &x, const double_v &y) { return _mm_max_pd(x.data(), y.data()); }
514 
515 static Vc_ALWAYS_INLINE Vc_PURE sfloat_v min(const sfloat_v &x, const sfloat_v &y) {
516  return M256::create(_mm_min_ps(x.data()[0], y.data()[0]), _mm_min_ps(x.data()[1], y.data()[1]));
517 }
518 static Vc_ALWAYS_INLINE Vc_PURE sfloat_v max(const sfloat_v &x, const sfloat_v &y) {
519  return M256::create(_mm_max_ps(x.data()[0], y.data()[0]), _mm_max_ps(x.data()[1], y.data()[1]));
520 }
521 
522  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> sqrt (const Vector<T> &x) { return VectorHelper<T>::sqrt(x.data()); }
523  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> rsqrt(const Vector<T> &x) { return VectorHelper<T>::rsqrt(x.data()); }
524  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> abs (const Vector<T> &x) { return VectorHelper<T>::abs(x.data()); }
525  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> reciprocal(const Vector<T> &x) { return VectorHelper<T>::reciprocal(x.data()); }
526  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> round(const Vector<T> &x) { return VectorHelper<T>::round(x.data()); }
527 
528  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE typename Vector<T>::Mask isfinite(const Vector<T> &x) { return VectorHelper<T>::isFinite(x.data()); }
529  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE typename Vector<T>::Mask isnan(const Vector<T> &x) { return VectorHelper<T>::isNaN(x.data()); }
530 
531 #include "forceToRegisters.tcc"
532 #ifdef VC_GNU_ASM
533 template<>
534 Vc_ALWAYS_INLINE void forceToRegisters(const Vector<float8> &x1) {
535  __asm__ __volatile__(""::"x"(x1.data()[0]), "x"(x1.data()[1]));
536 }
537 #elif defined(VC_MSVC)
538 #pragma optimize("g", off)
539 template<>
540 Vc_ALWAYS_INLINE void forceToRegisters(const Vector<float8> &/*x1*/) {
541 }
542 #endif
543 } // namespace SSE
544 } // namespace Vc
545 } // namespace ROOT
546 
547 #include "undomacros.h"
548 #include "vector.tcc"
549 #include "math.h"
550 #endif // SSE_VECTOR_H
ROOT::Vc::SSE::Vector::StorageType
VectorTraits< T >::StorageType StorageType
Definition: vector.h:146
ROOT::Vc::SSE::Vector::operator-
Vc_ALWAYS_INLINE_L Vector< typename NegateTypeHelper< T >::Type > operator-() const Vc_ALWAYS_INLINE_R
ROOT::Vc::SSE::Vector::cdab
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > cdab() const Vc_INTRINSIC_R Vc_PURE_R
ROOT::Vc::SSE::Vector::EntryType
VectorTraits< T >::EntryType EntryType
Definition: vector.h:156
ROOT::Vc::SSE::WriteMaskedVector::operator*=
Vc_INTRINSIC Vector< T > & operator*=(EntryType x)
Definition: vector.h:103
ROOT::Vc::SSE::SortHelper::sort
static Vc_CONST_L VectorType sort(VectorType) Vc_CONST_R
ROOT::Vc::SSE::Vector::operator=
Vc_ALWAYS_INLINE Vector & operator=(EntryType a)
Definition: vector.h:202
ROOT::Vc::SSE::Vector::fill
Vc_INTRINSIC void fill(EntryType(&f)(IndexT))
Definition: vector.h:465
ROOT::Vc::SSE::VectorTraits::EntryType
DetermineEntryType< T >::Type EntryType
Definition: types.h:137
ROOT::Vc::SSE::VectorTraits::GatherMaskType
DetermineGatherMask< MaskType >::Type GatherMaskType
Definition: types.h:143
Vc_foreach_bit
#define Vc_foreach_bit(_it_, _mask_)
Definition: mask.h:202
template
Small helper to encapsulate whether to return the value pointed to by the iterator or its address...
ROOT::Vc::SSE::sqrt
static Vc_ALWAYS_INLINE Vc_PURE Vector< T > sqrt(const Vector< T > &x)
Definition: vector.h:522
ROOT::Vc::SSE::Vector::operator--
Vc_INTRINSIC Vector operator--(int)
Definition: vector.h:302
ROOT::Vc::SSE::Vector::staticCast
Vc_ALWAYS_INLINE Vc_PURE V2 staticCast() const
Definition: vector.h:372
ROOT::Vc::SSE::Vector::operator~
Vc_INTRINSIC Vector Vc_PURE operator~() const
Definition: vector.h:312
ROOT::Vc::SSE::Vector::copySign
Vc_INTRINSIC_L Vector copySign(typename Vector::AsArg reference) const Vc_INTRINSIC_R
ROOT::Vc::SSE::WriteMaskedVector::call
Vc_INTRINSIC void call(F &f) const
Definition: vector.h:123
ROOT::Vc::SSE::Vector::setZero
Vc_INTRINSIC_L void setZero() Vc_INTRINSIC_R
FREE_STORE_OPERATORS_ALIGNED
#define FREE_STORE_OPERATORS_ALIGNED(alignment)
Definition: macros.h:165
ROOT::Vc::SSE::isnan
static Vc_ALWAYS_INLINE Vc_PURE Vector< T >::Mask isnan(const Vector< T > &x)
Definition: vector.h:529
ROOT::Vc::SSE::Vector::d
StorageType d
Definition: vector.h:147
ROOT::Vc::SSE::Vector::operator++
Vc_INTRINSIC Vector & operator++()
Definition: vector.h:298
ROOT::Vc::SSE::Vector::Random
static Vc_INTRINSIC_L Vector Random() Vc_INTRINSIC_R
ROOT::Vc::SSE::Vector::bcad
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > bcad() const Vc_INTRINSIC_R Vc_PURE_R
ROOT::Vc::SSE::Vector::product
Vc_INTRINSIC EntryType product() const
Definition: vector.h:391
ROOT::Vc::SSE::WriteMaskedVector::operator=
Vc_INTRINSIC Vector< T > & operator=(EntryType x)
Definition: vector.h:115
ROOT::Vc::SSE::WriteMaskedVector::apply
Vc_INTRINSIC Vector< T > apply(const F &f) const
Definition: vector.h:126
ROOT::Vc::SSE::Mask::data
Vc_ALWAYS_INLINE Vc_PURE _M128 data() const
Definition: mask.h:134
ROOT::Vc::SSE::WriteMaskedVector::Mask
VectorTraits< T >::MaskType Mask
Definition: vector.h:50
Vc_PURE_L
#define Vc_PURE_L
Definition: macros.h:137
a
TArc * a
Definition: textangle.C:12
ROOT::Vc::SSE::Vector::VC_EXACT_TYPE
Vc_INTRINSIC_L VC_EXACT_TYPE(TT, typename DetermineEntryType< T >::Type, Vector< T >) operator/(TT x) const Vc_PURE Vc_INTRINSIC_R
ROOT::Vc::SSE::Vector::apply
Vc_INTRINSIC Vector< T > apply(const F &f, const Mask &mask) const
Definition: vector.h:450
ROOT::Vc::SSE::M256::create
static Vc_INTRINSIC Vc_CONST M256 create(_M128 a, _M128 b)
Definition: types.h:70
ROOT::Vc::SSE::Vector::operator>>
Vc_INTRINSIC_L Vector operator>>(AsArg shift) const Vc_INTRINSIC_R
ROOT::Vc::SSE::Vector::setQnan
Vc_INTRINSIC_L void setQnan() Vc_INTRINSIC_R
Vc_INTRINSIC
#define Vc_INTRINSIC
Definition: macros.h:139
ROOT::Vc::SSE::Vector::shifted
Vc_INTRINSIC_L Vector shifted(int amount) const Vc_INTRINSIC_R
ROOT::Vc::Common::VectorMemoryUnion::m
Vc_ALWAYS_INLINE Vc_PURE AliasingEntryType & m(size_t index)
Definition: storage.h:86
ROOT::Vc::SSE::Vector::call
Vc_INTRINSIC void call(const F &f, const Mask &mask) const
Definition: vector.h:424
ROOT::Vc::SSE::Vector::call
Vc_INTRINSIC void call(F &f, const Mask &mask) const
Definition: vector.h:429
ROOT::Vc::SSE::Vector::operator()
Vc_INTRINSIC WriteMaskedVector< T > operator()(const Mask &k)
Definition: vector.h:375
ROOT::Math::Cephes::A
static double A[]
Definition: SpecFuncCephes.cxx:170
ROOT::Vc::SSE::Vector::sum
Vc_INTRINSIC EntryType sum() const
Definition: vector.h:392
ROOT::Vc::SSE::Vector::GatherMask
VectorTraits< T >::GatherMaskType GatherMask
Definition: vector.h:148
ROOT::Vc::SSE::Vector::Vector
Vc_INTRINSIC Vector(TT x, VC_EXACT_TYPE(TT, EntryType, void *)=0)
Definition: vector.h:200
f
TFile * f
Definition: memstatExample.C:52
ROOT::Vc::SSE::Vector::bbbb
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > bbbb() const Vc_INTRINSIC_R Vc_PURE_R
ROOT::Vc::SSE::WriteMaskedVector::operator=
Vc_INTRINSIC Vector< T > & operator=(const Vector< T > &x)
Definition: vector.h:110
ROOT::Vc::SSE::Vector::operator/=
Vc_INTRINSIC_L Vector & operator/=(const Vector< T > &x) Vc_INTRINSIC_R
ROOT::Vc::short_v
VECTOR_NAMESPACE::short_v short_v
Definition: vector.h:90
ROOT::Vc::SSE::Vector::acbd
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > acbd() const Vc_INTRINSIC_R Vc_PURE_R
T
TTree * T
Definition: memstatExample.C:53
ROOT::Vc::Scalar::forceToRegisters
static Vc_ALWAYS_INLINE void forceToRegisters(const Vector< T1 > &, const Vector< T2 > &, const Vector< T3 > &, const Vector< T4 > &, const Vector< T5 > &, const Vector< T6 > &, const Vector< T7 > &, const Vector< T8 > &, const Vector< T9 > &, const Vector< T10 > &, const Vector< T11 > &, const Vector< T12 > &, const Vector< T13 > &, const Vector< T14 > &, const Vector< T15 > &, const Vector< T16 > &)
Definition: vector.h:462
ROOT::Vc::Warnings::_operator_bracket_warning
void _operator_bracket_warning()
Definition: const.cpp:512
ROOT::Vc::SSE::mm_max_epu32
static Vc_INTRINSIC __m128i Vc_CONST mm_max_epu32(__m128i a, __m128i b)
Definition: intrinsics.h:432
sqrt
double sqrt(double)
ROOT::Vc::SSE::Vector::gather
void gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
x
Double_t x[n]
Definition: legend1.C:17
ROOT::Vc::SSE::WriteMaskedVector::EntryType
Vector< T >::EntryType EntryType
Definition: vector.h:51
ROOT::Vc::SSE::Vector::Zero
static Vc_INTRINSIC_L Vector Zero() Vc_INTRINSIC_R
ROOT::Vc::SSE::Vector::operator=
Vc_INTRINSIC_L Vector & operator=(const Vector< OtherT > &x) Vc_INTRINSIC_R
ROOT::Vc::SSE::abs
static Vc_ALWAYS_INLINE Vc_PURE Vector< T > abs(const Vector< T > &x)
Definition: vector.h:524
for_all_vector_entries
#define for_all_vector_entries(_it_, _code_)
Definition: macros.h:202
align
void align()
Definition: geodemo.C:1778
ROOT::Vc::SSE::WriteMaskedVector::vec
Vector< T > *const vec
Definition: vector.h:135
ROOT::Vc::AVX::Intrinsics::xor_
static Vc_ALWAYS_INLINE Vc_PURE m256 xor_(param256 a, param256 b)
Definition: mask.h:211
ROOT::Vc::SSE::Vector::dbca
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > dbca() const Vc_INTRINSIC_R Vc_PURE_R
ROOT::Vc::SSE::Vector::isNegative
cmpneq cmpnle cmple Vc_INTRINSIC_L Vc_PURE_L Mask isNegative() const Vc_PURE_R Vc_INTRINSIC_R
ROOT::Vc::SSE::Vector::operator[]
Vc_INTRINSIC Common::AliasingEntryHelper< StorageType > operator[](size_t index)
Definition: vector.h:304
ROOT::Vc::SSE::Vector::reinterpretCast
Vc_ALWAYS_INLINE Vc_PURE V2 reinterpretCast() const
Definition: vector.h:373
ROOT::Vc::SSE::Vector::cccc
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > cccc() const Vc_INTRINSIC_R Vc_PURE_R
ROOT::Vc::SSE::mm_max_epu16
static Vc_INTRINSIC __m128i Vc_CONST mm_max_epu16(__m128i a, __m128i b)
Definition: intrinsics.h:429
ROOT::Vc::SSE::WriteMaskedVector::operator++
Vc_INTRINSIC Vector< T > operator++(int)
Definition: vector.h:68
ROOT::Vc::SSE::Vector::scatter
void scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes) const
ROOT::Vc::SSE::round
static Vc_ALWAYS_INLINE Vc_PURE Vector< T > round(const Vector< T > &x)
Definition: vector.h:526
ROOT::Vc::SSE::Vector::fusedMultiplyAdd
Vc_ALWAYS_INLINE void fusedMultiplyAdd(const Vector< T > &factor, const Vector< T > &summand)
Definition: vector.h:363
ROOT::Vc::SSE::Vector::assign
Vc_ALWAYS_INLINE void assign(const Vector< T > &v, const Mask &mask)
Definition: vector.h:367
ROOT::Vc::SSE::Vector::operator++
Vc_INTRINSIC Vector operator++(int)
Definition: vector.h:301
Vc_PURE
#define Vc_PURE
Definition: macros.h:136
ROOT::Vc::SSE::Vector::bcda
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > bcda() const Vc_INTRINSIC_R Vc_PURE_R
Vc_ALWAYS_INLINE_R
#define Vc_ALWAYS_INLINE_R
Definition: macros.h:132
_pythonization.cast
def cast
Definition: _pythonization.py:48
ROOT::Vc::Common::VectorMemoryUnion::v
Vc_ALWAYS_INLINE Vc_PURE VectorType & v()
Definition: storage.h:83
ROOT::Vc::SSE::Vector::max
Vc_INTRINSIC EntryType max() const
Definition: vector.h:390
F
#define F(x, y, z)
VC_ALIGNED_PARAMETER
#define VC_ALIGNED_PARAMETER(_Type)
Definition: macros.h:368
ROOT::Vc::SSE::Vector::store
Vc_INTRINSIC_L void store(EntryType *mem) const Vc_INTRINSIC_R
r
ROOT::R::TRInterface & r
Definition: Object.C:4
v
SVector< double, 2 > v
Definition: Dict.h:5
ROOT::Vc::SSE::Vector::Mask
VectorTraits< T >::MaskType Mask
Definition: vector.h:158
Vc_INTRINSIC_R
#define Vc_INTRINSIC_R
Definition: macros.h:141
ROOT::Vc::SSE::WriteMaskedVector::operator/=
Vc_INTRINSIC Vector< T > & operator/=(const Vector< T > &x)
ROOT::Vc::SSE::Vector::apply
Vc_INTRINSIC Vector< T > apply(const F &f) const
Definition: vector.h:435
m
TMarker * m
Definition: textangle.C:8
ROOT::Vc::SSE::Vector::IndexesFromZero
static Vc_INTRINSIC_L Vector IndexesFromZero() Vc_INTRINSIC_R
ROOT::Vc::SSE::Vector::dddd
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > dddd() const Vc_INTRINSIC_R Vc_PURE_R
ROOT::Vc::SSE::Vector::badc
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > badc() const Vc_INTRINSIC_R Vc_PURE_R
ROOT::Vc::SSE::Vector::dabc
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > dabc() const Vc_INTRINSIC_R Vc_PURE_R
ROOT::Vc::SSE::Vector::aaaa
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > aaaa() const Vc_INTRINSIC_R Vc_PURE_R
_M128
#define _M128
Definition: macros.h:27
ROOT::Vc::SSE::Vector::broadcast4
static Vc_INTRINSIC Vector broadcast4(const EntryType *x)
Definition: vector.h:201
ROOT::Vc::SSE::Vector::One
static Vc_INTRINSIC_L Vector One() Vc_INTRINSIC_R
ROOT::Vc::SSE::WriteMaskedVector::operator+=
Vc_INTRINSIC Vector< T > & operator+=(EntryType x)
Definition: vector.h:97
ROOT::Vc::SSE::Vector::callWithValuesSorted
void callWithValuesSorted(F &f)
Definition: vector.h:402
ROOT::Vc::SSE::rsqrt
static Vc_ALWAYS_INLINE Vc_PURE Vector< T > rsqrt(const Vector< T > &x)
Definition: vector.h:523
ROOT::Vc::SSE::WriteMaskedVector::WriteMaskedVector
Vc_ALWAYS_INLINE WriteMaskedVector(Vector< T > *v, const Mask &k)
Definition: vector.h:134
ROOT::Vc::SSE::mm_min_epu16
static Vc_INTRINSIC __m128i Vc_CONST mm_min_epu16(__m128i a, __m128i b)
Definition: intrinsics.h:438
ROOT::Vc::SSE::Vector::HV
VectorHelper< typename VectorTraits< T >::VectorType > HV
Definition: vector.h:149
ROOT::Vc::SSE::Vector::apply
Vc_INTRINSIC Vector< T > apply(F &f, const Mask &mask) const
Definition: vector.h:457
ROOT::Math::IntegrationOneDim::Type
Type
enumeration specifying the integration types.
Definition: AllIntegrationTypes.h:45
ROOT::Vc::SSE::reciprocal
static Vc_ALWAYS_INLINE Vc_PURE Vector< T > reciprocal(const Vector< T > &x)
Definition: vector.h:525
ROOT::Vc::SSE::VectorTraits::VectorType
VectorTypeHelper< T >::Type VectorType
Definition: types.h:136
blend
#define blend
ROOT::Vc::SSE::Vector::dcba
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > dcba() const Vc_INTRINSIC_R Vc_PURE_R
ROOT::Vc::Memory
A helper class for fixed-size two-dimensional arrays.
Definition: memory.h:120
ROOT::Vc::SSE::Vector::IndexType
VectorTraits< T >::IndexType IndexType
Definition: vector.h:157
ROOT::Vc::SSE::Vector::Memory
Vc::Memory< Vector< T >, Size > Memory
Definition: vector.h:160
Vc_ALWAYS_INLINE
#define Vc_ALWAYS_INLINE
Definition: macros.h:130
RooFit::Index
RooCmdArg Index(RooCategory &icat)
Definition: RooGlobalFunc.cxx:96
ROOT::Vc::SSE::max
static Vc_ALWAYS_INLINE Vc_PURE sfloat_v max(const sfloat_v &x, const sfloat_v &y)
Definition: vector.h:518
ROOT::Vc::SSE::mm_min_epi32
static Vc_INTRINSIC __m128i Vc_CONST mm_min_epi32(__m128i a, __m128i b)
Definition: intrinsics.h:447
ROOT::Vc::AVX::Intrinsics::or_
static Vc_ALWAYS_INLINE Vc_PURE m256 or_(param256 a, param256 b)
Definition: mask.h:210
x1
static const double x1[5]
Definition: RooGaussKronrodIntegrator1D.cxx:327
ROOT::Vc::SSE::Vector::rotated
Vc_INTRINSIC_L Vector rotated(int amount) const Vc_INTRINSIC_R
ROOT::Vc::SSE::Vector::abcd
Vc_INTRINSIC_L Vc_PURE_L const Vector< T > & abcd() const Vc_INTRINSIC_R Vc_PURE_R
ROOT::Vc::AVX::Intrinsics::and_
static Vc_ALWAYS_INLINE Vc_PURE m256 and_(param256 a, param256 b)
Definition: mask.h:209
ROOT::Vc::SSE::Vector::operator<<
Vc_INTRINSIC_L Vector operator<<(AsArg shift) const Vc_INTRINSIC_R
ROOT::Vc::SSE::Vector::operator>>=
Vc_INTRINSIC_L Vector & operator>>=(AsArg shift) Vc_INTRINSIC_R
ROOT::Vc::SSE::WriteMaskedVector::operator+=
Vc_INTRINSIC Vector< T > & operator+=(const Vector< T > &x)
Definition: vector.h:83
ROOT::Vc::SSE::Vector::apply
Vc_INTRINSIC Vector< T > apply(F &f) const
Definition: vector.h:442
Vc_ALWAYS_INLINE_L
#define Vc_ALWAYS_INLINE_L
Definition: macros.h:131
ROOT::Vc::SSE::Vector::exponent
Vc_INTRINSIC_L Vector exponent() const Vc_INTRINSIC_R
ROOT::Vc::SSE::mm_min_epu32
static Vc_INTRINSIC __m128i Vc_CONST mm_min_epu32(__m128i a, __m128i b)
Definition: intrinsics.h:441
Vc_INTRINSIC_L
#define Vc_INTRINSIC_L
Definition: macros.h:140
ROOT::Vc::SSE::WriteMaskedVector::operator-=
Vc_INTRINSIC Vector< T > & operator-=(const Vector< T > &x)
Definition: vector.h:87
ROOT::Vc::SSE::Vector::VectorType
VectorTraits< T >::VectorType VectorType
Definition: vector.h:155
ROOT::Vc::SSE::Vector::OPcmp
cmpneq cmpnle OPcmp(<, cmplt) OPcmp(<
SSE
#define SSE
Definition: global.h:84
ROOT::Vc::SSE::WriteMaskedVector::operator*=
Vc_INTRINSIC Vector< T > & operator*=(const Vector< T > &x)
Definition: vector.h:91
ROOT::Vc::SSE::min
static Vc_ALWAYS_INLINE Vc_PURE sfloat_v min(const sfloat_v &x, const sfloat_v &y)
Definition: vector.h:515
ROOT::Vc::SSE::Vector::Vector
Vc_ALWAYS_INLINE Vector()
Definition: vector.h:171
ROOT::Vc::SSE::Vector::expand
void expand(Vector< typename ExpandTypeHelper< T >::Type > *x) const
ROOT::Vc::SSE::WriteMaskedVector::operator/=
Vc_INTRINSIC Vector< T > & operator/=(EntryType x)
Definition: vector.h:106
ROOT::Vc::SSE::WriteMaskedVector::operator--
Vc_INTRINSIC Vector< T > & operator--()
Definition: vector.h:61
ROOT::Vc::SSE::WriteMaskedVector::operator--
Vc_INTRINSIC Vector< T > operator--(int)
Definition: vector.h:75
ROOT::Vc::SSE::Vector::HT
VectorHelper< T > HT
Definition: vector.h:150
ROOT::Vc::SSE::Vector::data
Vc_ALWAYS_INLINE Vc_PURE const VectorType & data() const
Definition: vector.h:387
ROOT::Vc::SSE::Vector::call
Vc_INTRINSIC void call(F &f) const
Definition: vector.h:418
ROOT::Vc::SSE::Vector::AsArg
const Vector< T > AsArg
Definition: vector.h:164
ROOT::Vc::SSE::Vector::load
Vc_INTRINSIC_L void load(const EntryType *mem) Vc_INTRINSIC_R
OP
#define OP(symbol, fun)
Definition: vector.h:341
ROOT::Vc::SSE::Vector::operator=
Vc_ALWAYS_INLINE Vector & operator=(AsArg v)
Definition: vector.h:195
ROOT::Vc::SSE::Vector::operator<<=
Vc_INTRINSIC_L Vector & operator<<=(AsArg shift) Vc_INTRINSIC_R
ROOT::Vc::SSE::mm_max_epi32
static Vc_INTRINSIC __m128i Vc_CONST mm_max_epi32(__m128i a, __m128i b)
Definition: intrinsics.h:423
ROOT::Vc::SSE::isfinite
static Vc_ALWAYS_INLINE Vc_PURE Vector< T >::Mask isfinite(const Vector< T > &x)
Definition: vector.h:528
ROOT::Vc::SSE::Vector::call
Vc_INTRINSIC void call(const F &f) const
Definition: vector.h:413
ROOT::Vc::SSE::WriteMaskedVector::operator-=
Vc_INTRINSIC Vector< T > & operator-=(EntryType x)
Definition: vector.h:100
ROOT::Vc::SSE::WriteMaskedVector::apply
Vc_INTRINSIC Vector< T > apply(F &f) const
Definition: vector.h:129
ROOT::Vc::SSE::Vector::operator/
Vc_INTRINSIC_L Vector operator/(const Vector< T > &x) const Vc_PURE Vc_INTRINSIC_R
ROOT::Vc::SSE::Vector::fill
Vc_INTRINSIC void fill(EntryType(&f)())
Definition: vector.h:470
ROOT::Vc::SSE::WriteMaskedVector::call
Vc_INTRINSIC void call(const F &f) const
Definition: vector.h:120
value
float value
Definition: math.cpp:443
ROOT::Vc::SSE::Vector::sorted
Vc_PURE Vector sorted() const
Definition: vector.h:400
ROOT::Vc::SSE::mm128_reinterpret_cast
static Vc_ALWAYS_INLINE To Vc_CONST mm128_reinterpret_cast(VC_ALIGNED_PARAMETER(From) v)
Definition: casts.h:31
ROOT::Vc::SSE::Vector::MaskArg
Mask::Argument MaskArg
Definition: vector.h:159
ROOT::Vc::SSE::Vector::operator--
Vc_INTRINSIC Vector & operator--()
Definition: vector.h:299
fma
void fma()
Definition: arithmetics.cpp:409
V2
Double_t * V2
Definition: memstatExample.C:59
ROOT::Vc::SSE::Vector::data
Vc_ALWAYS_INLINE Vc_PURE VectorType & data()
Definition: vector.h:386
ROOT::Vc::SSE::Vector::min
Vc_INTRINSIC EntryType min() const
Definition: vector.h:389