← Back to branch summary

~ubuntu-branches/ubuntu/raring/vc/raring-proposed

« back to all changes in this revision

Viewing changes to scalar/vector.h

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-03-08 12:50:59 UTC
  • Revision ID: package-import@ubuntu.com-20130308125059-2vpu3hm02kgrqv96
Tags: upstream-0.7.0
Import upstream version 0.7.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
scalar/vector.h
 
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 SCALAR_VECTOR_H
 
21
#define SCALAR_VECTOR_H
 
22
 
 
23
#include <assert.h>
 
24
#include <algorithm>
 
25
#include <cmath>
 
26
 
 
27
#ifdef _MSC_VER
 
28
#include <float.h>
 
29
#endif
 
30
 
 
31
#include "../common/memoryfwd.h"
 
32
#include "macros.h"
 
33
#include "types.h"
 
34
#include "mask.h"
 
35
#include "writemaskedvector.h"
 
36
 
 
37
namespace Vc
 
38
{
 
39
namespace Scalar
 
40
{
 
41
    enum VectorAlignmentEnum { VectorAlignment = 4 };
 
42
 
 
43
template<typename T>
 
44
class Vector
 
45
{
 
46
    friend class WriteMaskedVector<T>;
 
47
    public:
 
48
        typedef typename DetermineEntryType<T>::Type EntryType;
 
49
    protected:
 
50
        EntryType m_data;
 
51
    public:
 
52
        typedef Vc::Memory<Vector<T>, 1> Memory;
 
53
        typedef Vector<unsigned int> IndexType;
 
54
        typedef Scalar::Mask<1u> Mask;
 
55
        typedef Vector<T> AsArg;
 
56
 
 
57
        Vc_ALWAYS_INLINE EntryType &data() { return m_data; }
 
58
        Vc_ALWAYS_INLINE EntryType data() const { return m_data; }
 
59
 
 
60
        enum Constants { Size = 1 };
 
61
 
 
62
        ///////////////////////////////////////////////////////////////////////////////////////////
 
63
        // uninitialized
 
64
        Vc_ALWAYS_INLINE Vector() {}
 
65
 
 
66
        ///////////////////////////////////////////////////////////////////////////////////////////
 
67
        // constants
 
68
        Vc_ALWAYS_INLINE Vector(VectorSpecialInitializerZero::ZEnum) : m_data(0) {}
 
69
        Vc_ALWAYS_INLINE Vector(VectorSpecialInitializerOne::OEnum) : m_data(1) {}
 
70
        Vc_ALWAYS_INLINE Vector(VectorSpecialInitializerIndexesFromZero::IEnum) : m_data(0) {}
 
71
        static Vc_ALWAYS_INLINE Vector Zero() { Vector r; r.m_data = 0; return r; }
 
72
        static Vc_ALWAYS_INLINE Vector One() { Vector r; r.m_data = 1; return r; }
 
73
        static Vc_ALWAYS_INLINE Vector IndexesFromZero() { return Zero(); }
 
74
        static Vc_INTRINSIC_L Vector Random() Vc_INTRINSIC_R;
 
75
 
 
76
        ///////////////////////////////////////////////////////////////////////////////////////////
 
77
        // static_cast / copy ctor
 
78
        template<typename OtherT> explicit Vc_ALWAYS_INLINE Vector(const Vector<OtherT> &x) : m_data(static_cast<EntryType>(x.data())) {}
 
79
 
 
80
        // implicit cast
 
81
        template<typename OtherT> Vc_ALWAYS_INLINE_L Vector &operator=(const Vector<OtherT> &x) Vc_ALWAYS_INLINE_R;
 
82
 
 
83
        // copy assignment
 
84
        Vc_ALWAYS_INLINE Vector &operator=(Vector v) { m_data = v.data(); return *this; }
 
85
 
 
86
        ///////////////////////////////////////////////////////////////////////////////////////////
 
87
        // broadcast
 
88
        explicit Vc_ALWAYS_INLINE Vector(EntryType x) : m_data(x) {}
 
89
        template<typename TT> Vc_ALWAYS_INLINE Vector(TT x, VC_EXACT_TYPE(TT, EntryType, void *) = 0) : m_data(x) {}
 
90
        Vc_ALWAYS_INLINE Vector &operator=(EntryType a) { m_data = a; return *this; }
 
91
 
 
92
        ///////////////////////////////////////////////////////////////////////////////////////////
 
93
        // load ctors
 
94
        explicit Vc_ALWAYS_INLINE Vector(const EntryType *x) : m_data(x[0]) {}
 
95
        template<typename A> Vc_ALWAYS_INLINE Vector(const EntryType *x, A) : m_data(x[0]) {}
 
96
        template<typename Other> explicit Vc_ALWAYS_INLINE Vector(const Other *x) : m_data(x[0]) {}
 
97
        template<typename Other, typename A> Vc_ALWAYS_INLINE Vector(const Other *x, A) : m_data(x[0]) {}
 
98
 
 
99
        ///////////////////////////////////////////////////////////////////////////////////////////
 
100
        // expand 1 float_v to 2 double_v                 XXX rationale? remove it for release? XXX
 
101
        template<typename OtherT> Vc_ALWAYS_INLINE void expand(Vector<OtherT> *x) const { x->data() = static_cast<OtherT>(m_data); }
 
102
        template<typename OtherT> explicit Vc_ALWAYS_INLINE Vector(const Vector<OtherT> *a) : m_data(static_cast<EntryType>(a->data())) {}
 
103
 
 
104
        ///////////////////////////////////////////////////////////////////////////////////////////
 
105
        // zeroing
 
106
        Vc_ALWAYS_INLINE void setZero() { m_data = 0; }
 
107
        Vc_ALWAYS_INLINE void setZero(Mask k) { if (k) m_data = 0; }
 
108
 
 
109
        Vc_INTRINSIC_L void setQnan() Vc_INTRINSIC_R;
 
110
        Vc_INTRINSIC_L void setQnan(Mask m) Vc_INTRINSIC_R;
 
111
 
 
112
        ///////////////////////////////////////////////////////////////////////////////////////////
 
113
        // load member functions
 
114
        template<typename Other> Vc_ALWAYS_INLINE void load(const Other *mem) { m_data = mem[0]; }
 
115
        template<typename Other, typename A> Vc_ALWAYS_INLINE void load(const Other *mem, A) { m_data = mem[0]; }
 
116
        template<typename Other> Vc_ALWAYS_INLINE void load(const Other *mem, Mask m) { if (m.data()) m_data = mem[0]; }
 
117
 
 
118
        Vc_ALWAYS_INLINE void load(const EntryType *mem) { m_data = mem[0]; }
 
119
        template<typename A> Vc_ALWAYS_INLINE void load(const EntryType *mem, A) { m_data = mem[0]; }
 
120
        Vc_ALWAYS_INLINE void load(const EntryType *mem, Mask m) { if (m.data()) m_data = mem[0]; }
 
121
 
 
122
        ///////////////////////////////////////////////////////////////////////////////////////////
 
123
        // stores
 
124
        Vc_ALWAYS_INLINE void store(EntryType *mem) const { mem[0] = m_data; }
 
125
        Vc_ALWAYS_INLINE void store(EntryType *mem, Mask m) const { if (m.data()) mem[0] = m_data; }
 
126
        template<typename A> Vc_ALWAYS_INLINE void store(EntryType *mem, A) const { store(mem); }
 
127
        template<typename A> Vc_ALWAYS_INLINE void store(EntryType *mem, Mask m, A) const { store(mem, m); }
 
128
 
 
129
        ///////////////////////////////////////////////////////////////////////////////////////////
 
130
        // swizzles
 
131
        Vc_INTRINSIC const Vector<T> &abcd() const { return *this; }
 
132
        Vc_INTRINSIC const Vector<T>  cdab() const { return *this; }
 
133
        Vc_INTRINSIC const Vector<T>  badc() const { return *this; }
 
134
        Vc_INTRINSIC const Vector<T>  aaaa() const { return *this; }
 
135
        Vc_INTRINSIC const Vector<T>  bbbb() const { return *this; }
 
136
        Vc_INTRINSIC const Vector<T>  cccc() const { return *this; }
 
137
        Vc_INTRINSIC const Vector<T>  dddd() const { return *this; }
 
138
        Vc_INTRINSIC const Vector<T>  bcad() const { return *this; }
 
139
        Vc_INTRINSIC const Vector<T>  bcda() const { return *this; }
 
140
        Vc_INTRINSIC const Vector<T>  dabc() const { return *this; }
 
141
        Vc_INTRINSIC const Vector<T>  acbd() const { return *this; }
 
142
        Vc_INTRINSIC const Vector<T>  dbca() const { return *this; }
 
143
        Vc_INTRINSIC const Vector<T>  dcba() const { return *this; }
 
144
 
 
145
        ///////////////////////////////////////////////////////////////////////////////////////////
 
146
        // gathers
 
147
        template<typename IndexT> Vc_ALWAYS_INLINE Vector(const EntryType *array, const IndexT *indexes) : m_data(array[indexes[0]]) {}
 
148
        template<typename IndexT> Vc_ALWAYS_INLINE Vector(const EntryType *array, Vector<IndexT> indexes) : m_data(array[indexes[0]]) {}
 
149
        template<typename IndexT> Vc_ALWAYS_INLINE Vector(const EntryType *array, IndexT indexes, Mask m) : m_data(m.data() ? array[indexes[0]] : 0) {}
 
150
        template<typename S1, typename IT> Vc_ALWAYS_INLINE Vector(const S1 *array, const EntryType S1::* member1, IT indexes, Mask mask = Mask(true))
 
151
            : m_data(mask.data() ? (&array[indexes[0]])->*(member1) : 0) {}
 
152
        template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE Vector(const S1 *array, const S2 S1::* member1,
 
153
                const EntryType S2::* member2, IT indexes, Mask mask = Mask(true))
 
154
            : m_data(mask.data() ? array[indexes[0]].*(member1).*(member2) : 0) {}
 
155
        template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE Vector(const S1 *array, const EntryType *const S1::* ptrMember1,
 
156
                IT1 outerIndex, IT2 innerIndex, Mask mask = Mask(true))
 
157
            : m_data(mask.data() ? (array[outerIndex[0]].*(ptrMember1))[innerIndex[0]] : 0) {}
 
158
 
 
159
        template<typename IT> Vc_ALWAYS_INLINE void gather(const EntryType *array, IT indexes, Mask mask = Mask(true))
 
160
            { if (mask.data()) m_data = array[indexes[0]]; }
 
161
        template<typename S1, typename IT> Vc_ALWAYS_INLINE void gather(const S1 *array, const EntryType S1::* member1, IT indexes, Mask mask = Mask(true))
 
162
            { if (mask.data()) m_data = (&array[indexes[0]])->*(member1); }
 
163
        template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE void gather(const S1 *array, const S2 S1::* member1,
 
164
                const EntryType S2::* member2, IT indexes, Mask mask = Mask(true))
 
165
            { if (mask.data()) m_data = array[indexes[0]].*(member1).*(member2); }
 
166
        template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE void gather(const S1 *array, const EntryType *const S1::* ptrMember1,
 
167
                IT1 outerIndex, IT2 innerIndex, Mask mask = Mask(true))
 
168
            { if (mask.data()) m_data = (array[outerIndex[0]].*(ptrMember1))[innerIndex[0]]; }
 
169
 
 
170
        ///////////////////////////////////////////////////////////////////////////////////////////
 
171
        // scatters
 
172
        Vc_ALWAYS_INLINE void scatter(EntryType *array, const Vector<unsigned int> &indexes, Mask m = Mask(true)) const { if (m.data()) array[indexes[0]] = m_data; }
 
173
        template<typename S1> Vc_ALWAYS_INLINE void scatter(S1 *array, EntryType S1::* member, const Vector<unsigned int> &indexes, Mask m = Mask(true)) const {
 
174
            if (m.data()) array[indexes[0]].*(member) = m_data;
 
175
        }
 
176
        template<typename S1, typename S2> Vc_ALWAYS_INLINE void scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2,
 
177
                const Vector<unsigned int> &indexes, Mask m = Mask(true)) const {
 
178
            if (m.data()) array[indexes[0]].*(member1).*(member2) = m_data;
 
179
        }
 
180
 
 
181
        Vc_ALWAYS_INLINE void scatter(EntryType *array, const Vector<unsigned short> &indexes, Mask m = Mask(true)) const { if (m.data()) array[indexes[0]] = m_data; }
 
182
        template<typename S1> Vc_ALWAYS_INLINE void scatter(S1 *array, EntryType S1::* member, const Vector<unsigned short> &indexes, Mask m = Mask(true)) const {
 
183
            if (m.data()) array[indexes[0]].*(member) = m_data;
 
184
        }
 
185
        template<typename S1, typename S2> Vc_ALWAYS_INLINE void scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2,
 
186
                const Vector<unsigned short> &indexes, Mask m = Mask(true)) const {
 
187
            if (m.data()) array[indexes[0]].*(member1).*(member2) = m_data;
 
188
        }
 
189
 
 
190
        //prefix
 
191
        Vc_ALWAYS_INLINE Vector &operator++() { ++m_data; return *this; }
 
192
        //postfix
 
193
        Vc_ALWAYS_INLINE Vector operator++(int) { return m_data++; }
 
194
 
 
195
        Vc_ALWAYS_INLINE EntryType &operator[](int index) {
 
196
            assert(index == 0); if(index) {}
 
197
            return m_data;
 
198
        }
 
199
 
 
200
        Vc_ALWAYS_INLINE EntryType operator[](int index) const {
 
201
            assert(index == 0); if(index) {}
 
202
            return m_data;
 
203
        }
 
204
 
 
205
        Vc_ALWAYS_INLINE Vector operator~() const { return Vector(~m_data); }
 
206
        Vc_ALWAYS_INLINE Vector<typename NegateTypeHelper<T>::Type> operator-() const { return Vector<typename NegateTypeHelper<T>::Type>(-m_data); }
 
207
        Vc_INTRINSIC Vector Vc_PURE operator+() const { return *this; }
 
208
 
 
209
#define OPshift(symbol) \
 
210
        Vc_ALWAYS_INLINE Vector &operator symbol##=(const Vector<T> &x) { m_data symbol##= x.m_data; return *this; } \
 
211
        Vc_ALWAYS_INLINE Vector &operator symbol##=(EntryType x) { return operator symbol##=(Vector(x)); } \
 
212
        Vc_ALWAYS_INLINE Vector operator symbol(const Vector<T> &x) const { return Vector<T>(m_data symbol x.m_data); }
 
213
#define OPshift_int(symbol) \
 
214
        Vc_ALWAYS_INLINE Vector operator symbol(int x) const { return Vector(m_data symbol x); }
 
215
#define OP(symbol) \
 
216
        OPshift(symbol) \
 
217
        template<typename TT> Vc_ALWAYS_INLINE VC_EXACT_TYPE(TT, EntryType, Vector) operator symbol(TT x) const { return operator symbol(Vector(x)); }
 
218
#define OPcmp(symbol) \
 
219
        Vc_ALWAYS_INLINE Mask operator symbol(const Vector<T> &x) const { return Mask(m_data symbol x.m_data); } \
 
220
        template<typename TT> Vc_ALWAYS_INLINE VC_EXACT_TYPE(TT, EntryType, Mask) operator symbol(TT x) const { return Mask(m_data symbol x); }
 
221
 
 
222
        VC_ALL_ARITHMETICS(OP)
 
223
        VC_ALL_BINARY(OP)
 
224
        VC_ALL_SHIFTS(OPshift)
 
225
        VC_ALL_SHIFTS(OPshift_int)
 
226
        VC_ALL_COMPARES(OPcmp)
 
227
#undef OP
 
228
#undef OPcmp
 
229
#undef OPshift
 
230
#undef OPshift_int
 
231
        Vc_INTRINSIC_L Vc_PURE_L Mask isNegative() const Vc_PURE_R Vc_INTRINSIC_R;
 
232
 
 
233
        Vc_ALWAYS_INLINE void fusedMultiplyAdd(const Vector<T> &factor, const Vector<T> &summand) {
 
234
            m_data = m_data * factor.data() + summand.data();
 
235
        }
 
236
 
 
237
        Vc_ALWAYS_INLINE void assign(const Vector<T> &v, const Mask &m) {
 
238
          if (m.data()) m_data = v.m_data;
 
239
        }
 
240
 
 
241
        template<typename V2> Vc_ALWAYS_INLINE V2 staticCast() const { return V2(static_cast<typename V2::EntryType>(m_data)); }
 
242
        template<typename V2> Vc_ALWAYS_INLINE V2 reinterpretCast() const {
 
243
            typedef typename V2::EntryType AliasT2 Vc_MAY_ALIAS;
 
244
            return V2(*reinterpret_cast<const AliasT2 *>(&m_data));
 
245
        }
 
246
 
 
247
        Vc_ALWAYS_INLINE WriteMaskedVector<T> operator()(Mask m) { return WriteMaskedVector<T>(this, m); }
 
248
 
 
249
        Vc_ALWAYS_INLINE bool pack(Mask &m1, Vector<T> &v2, Mask &m2) {
 
250
            if (!m1.data() && m2.data()) {
 
251
                m_data = v2.m_data;
 
252
                m1 = true;
 
253
                m2 = false;
 
254
                return true;
 
255
            }
 
256
            return m1;
 
257
        }
 
258
 
 
259
        Vc_ALWAYS_INLINE EntryType min() const { return m_data; }
 
260
        Vc_ALWAYS_INLINE EntryType max() const { return m_data; }
 
261
        Vc_ALWAYS_INLINE EntryType product() const { return m_data; }
 
262
        Vc_ALWAYS_INLINE EntryType sum() const { return m_data; }
 
263
        Vc_ALWAYS_INLINE EntryType min(Mask) const { return m_data; }
 
264
        Vc_ALWAYS_INLINE EntryType max(Mask) const { return m_data; }
 
265
        Vc_ALWAYS_INLINE EntryType product(Mask) const { return m_data; }
 
266
        Vc_ALWAYS_INLINE EntryType sum(Mask m) const { if (m) return m_data; return static_cast<EntryType>(0); }
 
267
 
 
268
        Vc_INTRINSIC Vector shifted(int amount) const { return amount == 0 ? *this : Zero(); }
 
269
        Vc_INTRINSIC Vector rotated(int) const { return *this; }
 
270
        Vector sorted() const { return *this; }
 
271
 
 
272
        template<typename F> void callWithValuesSorted(F &f) {
 
273
            f(m_data);
 
274
        }
 
275
 
 
276
        template<typename F> Vc_INTRINSIC void call(const F &f) const {
 
277
            f(m_data);
 
278
        }
 
279
        template<typename F> Vc_INTRINSIC void call(F &f) const {
 
280
            f(m_data);
 
281
        }
 
282
 
 
283
        template<typename F> Vc_INTRINSIC void call(const F &f, Mask mask) const {
 
284
            if (mask) {
 
285
                f(m_data);
 
286
            }
 
287
        }
 
288
        template<typename F> Vc_INTRINSIC void call(F &f, Mask mask) const {
 
289
            if (mask) {
 
290
                f(m_data);
 
291
            }
 
292
        }
 
293
 
 
294
        template<typename F> Vc_INTRINSIC Vector apply(const F &f) const {
 
295
            return Vector(f(m_data));
 
296
        }
 
297
        template<typename F> Vc_INTRINSIC Vector apply(F &f) const {
 
298
            return Vector(f(m_data));
 
299
        }
 
300
 
 
301
        template<typename F> Vc_INTRINSIC Vector apply(const F &f, Mask mask) const {
 
302
            if (mask) {
 
303
                return Vector(f(m_data));
 
304
            } else {
 
305
                return *this;
 
306
            }
 
307
        }
 
308
        template<typename F> Vc_INTRINSIC Vector apply(F &f, Mask mask) const {
 
309
            if (mask) {
 
310
                return Vector(f(m_data));
 
311
            } else {
 
312
                return *this;
 
313
            }
 
314
        }
 
315
 
 
316
        template<typename IndexT> Vc_INTRINSIC void fill(EntryType (&f)(IndexT)) {
 
317
            m_data = f(0);
 
318
        }
 
319
        Vc_INTRINSIC void fill(EntryType (&f)()) {
 
320
            m_data = f();
 
321
        }
 
322
 
 
323
        Vc_INTRINSIC_L Vector copySign(Vector reference) const Vc_INTRINSIC_R;
 
324
        Vc_INTRINSIC_L Vector exponent() const Vc_INTRINSIC_R;
 
325
};
 
326
 
 
327
typedef Vector<double>         double_v;
 
328
typedef Vector<float>          float_v;
 
329
typedef Vector<sfloat>         sfloat_v;
 
330
typedef Vector<int>            int_v;
 
331
typedef Vector<unsigned int>   uint_v;
 
332
typedef Vector<short>          short_v;
 
333
typedef Vector<unsigned short> ushort_v;
 
334
typedef double_v::Mask double_m;
 
335
typedef float_v::Mask float_m;
 
336
typedef sfloat_v::Mask sfloat_m;
 
337
typedef int_v::Mask int_m;
 
338
typedef uint_v::Mask uint_m;
 
339
typedef short_v::Mask short_m;
 
340
typedef ushort_v::Mask ushort_m;
 
341
 
 
342
template<typename T> class SwizzledVector : public Vector<T> {};
 
343
 
 
344
#ifdef _MSC_VER
 
345
  template<typename T> static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T> &) {
 
346
  }
 
347
#else
 
348
  template<typename T> static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T> &x01) {
 
349
      __asm__ __volatile__(""::"r"(x01.data()));
 
350
  }
 
351
  template<> Vc_ALWAYS_INLINE void forceToRegisters(const Vector<float> &x01) {
 
352
      __asm__ __volatile__(""::"x"(x01.data()));
 
353
  }
 
354
  template<> Vc_ALWAYS_INLINE void forceToRegisters(const Vector<double> &x01) {
 
355
      __asm__ __volatile__(""::"x"(x01.data()));
 
356
  }
 
357
#endif
 
358
  template<typename T1, typename T2> static Vc_ALWAYS_INLINE void forceToRegisters(
 
359
      const Vector<T1> &x01, const Vector<T2> &x02) {
 
360
      forceToRegisters(x01);
 
361
      forceToRegisters(x02);
 
362
  }
 
363
  template<typename T1, typename T2, typename T3> static Vc_ALWAYS_INLINE void forceToRegisters(
 
364
        const Vector<T1>  &,  const Vector<T2>  &, const Vector<T3>  &) {}
 
365
  template<typename T1, typename T2, typename T3, typename T4> static Vc_ALWAYS_INLINE void forceToRegisters(
 
366
        const Vector<T1>  &,  const Vector<T2>  &,
 
367
        const Vector<T3>  &,  const Vector<T4>  &) {}
 
368
  template<typename T1, typename T2, typename T3, typename T4, typename T5>
 
369
    static Vc_ALWAYS_INLINE void forceToRegisters(
 
370
        const Vector<T1>  &,  const Vector<T2>  &,
 
371
        const Vector<T3>  &,  const Vector<T4>  &,
 
372
        const Vector<T5>  &) {}
 
373
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 
374
    static Vc_ALWAYS_INLINE void forceToRegisters(
 
375
        const Vector<T1>  &,  const Vector<T2>  &,
 
376
        const Vector<T3>  &,  const Vector<T4>  &,
 
377
        const Vector<T5>  &,  const Vector<T6>  &) {}
 
378
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
 
379
    typename T7>
 
380
    static Vc_ALWAYS_INLINE void forceToRegisters(
 
381
        const Vector<T1>  &,  const Vector<T2>  &,
 
382
        const Vector<T3>  &,  const Vector<T4>  &,
 
383
        const Vector<T5>  &,  const Vector<T6>  &,
 
384
        const Vector<T7>  &) {}
 
385
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
 
386
    typename T7, typename T8>
 
387
    static Vc_ALWAYS_INLINE void forceToRegisters(
 
388
        const Vector<T1>  &,  const Vector<T2>  &,
 
389
        const Vector<T3>  &,  const Vector<T4>  &,
 
390
        const Vector<T5>  &,  const Vector<T6>  &,
 
391
        const Vector<T7>  &,  const Vector<T8>  &) {}
 
392
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
 
393
    typename T7, typename T8, typename T9>
 
394
    static Vc_ALWAYS_INLINE void forceToRegisters(
 
395
        const Vector<T1>  &,  const Vector<T2>  &,
 
396
        const Vector<T3>  &,  const Vector<T4>  &,
 
397
        const Vector<T5>  &,  const Vector<T6>  &,
 
398
        const Vector<T7>  &,  const Vector<T8>  &,
 
399
        const Vector<T9>  &) {}
 
400
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
 
401
    typename T7, typename T8, typename T9, typename T10>
 
402
    static Vc_ALWAYS_INLINE void forceToRegisters(
 
403
        const Vector<T1>  &, const Vector<T2>  &,
 
404
        const Vector<T3>  &, const Vector<T4>  &,
 
405
        const Vector<T5>  &, const Vector<T6>  &,
 
406
        const Vector<T7>  &, const Vector<T8>  &,
 
407
        const Vector<T9>  &, const Vector<T10> &) {}
 
408
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
 
409
    typename T7, typename T8, typename T9, typename T10, typename T11>
 
410
    static Vc_ALWAYS_INLINE void forceToRegisters(
 
411
        const Vector<T1>  &, const Vector<T2>  &,
 
412
        const Vector<T3>  &, const Vector<T4>  &,
 
413
        const Vector<T5>  &, const Vector<T6>  &,
 
414
        const Vector<T7>  &, const Vector<T8>  &,
 
415
        const Vector<T9>  &, const Vector<T10> &,
 
416
        const Vector<T11> &) {}
 
417
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
 
418
    typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
 
419
    static Vc_ALWAYS_INLINE void forceToRegisters(
 
420
        const Vector<T1>  &, const Vector<T2>  &,
 
421
        const Vector<T3>  &, const Vector<T4>  &,
 
422
        const Vector<T5>  &, const Vector<T6>  &,
 
423
        const Vector<T7>  &, const Vector<T8>  &,
 
424
        const Vector<T9>  &, const Vector<T10> &,
 
425
        const Vector<T11> &, const Vector<T12> &) {}
 
426
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
 
427
    typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
 
428
    static Vc_ALWAYS_INLINE void forceToRegisters(
 
429
        const Vector<T1>  &, const Vector<T2>  &,
 
430
        const Vector<T3>  &, const Vector<T4>  &,
 
431
        const Vector<T5>  &, const Vector<T6>  &,
 
432
        const Vector<T7>  &, const Vector<T8>  &,
 
433
        const Vector<T9>  &, const Vector<T10> &,
 
434
        const Vector<T11> &, const Vector<T12> &,
 
435
        const Vector<T13> &) {}
 
436
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
 
437
    typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
 
438
    typename T14> static Vc_ALWAYS_INLINE void forceToRegisters(
 
439
        const Vector<T1>  &, const Vector<T2>  &,
 
440
        const Vector<T3>  &, const Vector<T4>  &,
 
441
        const Vector<T5>  &, const Vector<T6>  &,
 
442
        const Vector<T7>  &, const Vector<T8>  &,
 
443
        const Vector<T9>  &, const Vector<T10> &,
 
444
        const Vector<T11> &, const Vector<T12> &,
 
445
        const Vector<T13> &, const Vector<T14> &) {}
 
446
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
 
447
    typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
 
448
    typename T14, typename T15> static Vc_ALWAYS_INLINE void forceToRegisters(
 
449
        const Vector<T1>  &, const Vector<T2>  &,
 
450
        const Vector<T3>  &, const Vector<T4>  &,
 
451
        const Vector<T5>  &, const Vector<T6>  &,
 
452
        const Vector<T7>  &, const Vector<T8>  &,
 
453
        const Vector<T9>  &, const Vector<T10> &,
 
454
        const Vector<T11> &, const Vector<T12> &,
 
455
        const Vector<T13> &, const Vector<T14> &,
 
456
        const Vector<T15> &) {}
 
457
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
 
458
    typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
 
459
    typename T14, typename T15, typename T16> static Vc_ALWAYS_INLINE void forceToRegisters(
 
460
        const Vector<T1>  &, const Vector<T2>  &,
 
461
        const Vector<T3>  &, const Vector<T4>  &,
 
462
        const Vector<T5>  &, const Vector<T6>  &,
 
463
        const Vector<T7>  &, const Vector<T8>  &,
 
464
        const Vector<T9>  &, const Vector<T10> &,
 
465
        const Vector<T11> &, const Vector<T12> &,
 
466
        const Vector<T13> &, const Vector<T14> &,
 
467
        const Vector<T15> &, const Vector<T16> &) {}
 
468
 
 
469
} // namespace Scalar
 
470
} // namespace Vc
 
471
 
 
472
#include "vector.tcc"
 
473
#include "math.h"
 
474
#include "undomacros.h"
 
475
 
 
476
#endif // SCALAR_VECTOR_H