← Back to branch summary

~ubuntu-branches/ubuntu/karmic/python-scipy/karmic

« back to all changes in this revision

Viewing changes to scipy/weave/blitz/blitz/vecuops.cc

  • Committer: Bazaar Package Importer
  • Author(s): Ondrej Certik
  • Date: 2008-06-16 22:58:01 UTC
  • mfrom: (2.1.24 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080616225801-irdhrpcwiocfbcmt
Tags: 0.6.0-12
http://bugs.debian.org/489149
* The description updated to match the current SciPy (Closes: #489149).
* Standards-Version bumped to 3.8.0 (no action needed)
* Build-Depends: netcdf-dev changed to libnetcdf-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
scipy/weave/blitz/blitz/vecuops.cc
 
1
/***************************************************************************
 
2
 * blitz/../vecuops.cc  Expression templates for vectors, unary functions
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU General Public License
 
6
 * as published by the Free Software Foundation; either version 2
 
7
 * of the License, or (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * Suggestions:          blitz-suggest@cybervision.com
 
15
 * Bugs:                 blitz-bugs@cybervision.com
 
16
 *
 
17
 * For more information, please see the Blitz++ Home Page:
 
18
 *    http://seurat.uwaterloo.ca/blitz/
 
19
 *
 
20
 ***************************************************************************
 
21
 *
 
22
 */ 
 
23
 
 
24
// Generated source file.  Do not edit. 
 
25
// genvecuops.cpp Oct  6 2005 15:58:48
 
26
 
 
27
#ifndef BZ_VECUOPS_CC
 
28
#define BZ_VECUOPS_CC
 
29
 
 
30
#ifndef BZ_VECEXPR_H
 
31
 #error <blitz/vecuops.cc> must be included via <blitz/vecexpr.h>
 
32
#endif // BZ_VECEXPR_H
 
33
 
 
34
BZ_NAMESPACE(blitz)
 
35
 
 
36
/****************************************************************************
 
37
 * abs
 
38
 ****************************************************************************/
 
39
 
 
40
template<class P_numtype1>
 
41
inline
 
42
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
43
    _bz_abs<P_numtype1> > >
 
44
abs(const Vector<P_numtype1>& d1)
 
45
{
 
46
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
47
        _bz_abs<P_numtype1> > T_expr;
 
48
 
 
49
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
50
}
 
51
 
 
52
template<class P_expr1>
 
53
inline
 
54
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
55
    _bz_abs<typename P_expr1::T_numtype> > >
 
56
abs(_bz_VecExpr<P_expr1> d1)
 
57
{
 
58
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
59
        _bz_abs<typename P_expr1::T_numtype> > T_expr;
 
60
 
 
61
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
62
}
 
63
 
 
64
template<class P_numtype1>
 
65
inline
 
66
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
67
    _bz_abs<P_numtype1> > >
 
68
abs(const VectorPick<P_numtype1>& d1)
 
69
{
 
70
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
71
        _bz_abs<P_numtype1> > T_expr;
 
72
 
 
73
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
74
}
 
75
 
 
76
 
 
77
inline
 
78
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
79
    _bz_abs<int> > >
 
80
abs(Range d1)
 
81
{
 
82
    typedef _bz_VecExprUnaryOp<Range,
 
83
        _bz_abs<int> > T_expr;
 
84
 
 
85
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
86
}
 
87
 
 
88
template<class P_numtype1, int N_length1>
 
89
inline
 
90
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
91
    _bz_abs<P_numtype1> > >
 
92
abs(const TinyVector<P_numtype1, N_length1>& d1)
 
93
{
 
94
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
95
        _bz_abs<P_numtype1> > T_expr;
 
96
 
 
97
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
98
}
 
99
 
 
100
 
 
101
/****************************************************************************
 
102
 * acos
 
103
 ****************************************************************************/
 
104
 
 
105
template<class P_numtype1>
 
106
inline
 
107
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
108
    _bz_acos<P_numtype1> > >
 
109
acos(const Vector<P_numtype1>& d1)
 
110
{
 
111
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
112
        _bz_acos<P_numtype1> > T_expr;
 
113
 
 
114
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
115
}
 
116
 
 
117
template<class P_expr1>
 
118
inline
 
119
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
120
    _bz_acos<typename P_expr1::T_numtype> > >
 
121
acos(_bz_VecExpr<P_expr1> d1)
 
122
{
 
123
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
124
        _bz_acos<typename P_expr1::T_numtype> > T_expr;
 
125
 
 
126
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
127
}
 
128
 
 
129
template<class P_numtype1>
 
130
inline
 
131
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
132
    _bz_acos<P_numtype1> > >
 
133
acos(const VectorPick<P_numtype1>& d1)
 
134
{
 
135
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
136
        _bz_acos<P_numtype1> > T_expr;
 
137
 
 
138
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
139
}
 
140
 
 
141
 
 
142
inline
 
143
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
144
    _bz_acos<int> > >
 
145
acos(Range d1)
 
146
{
 
147
    typedef _bz_VecExprUnaryOp<Range,
 
148
        _bz_acos<int> > T_expr;
 
149
 
 
150
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
151
}
 
152
 
 
153
template<class P_numtype1, int N_length1>
 
154
inline
 
155
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
156
    _bz_acos<P_numtype1> > >
 
157
acos(const TinyVector<P_numtype1, N_length1>& d1)
 
158
{
 
159
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
160
        _bz_acos<P_numtype1> > T_expr;
 
161
 
 
162
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
163
}
 
164
 
 
165
 
 
166
/****************************************************************************
 
167
 * acosh
 
168
 ****************************************************************************/
 
169
 
 
170
#ifdef BZ_HAVE_IEEE_MATH
 
171
template<class P_numtype1>
 
172
inline
 
173
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
174
    _bz_acosh<P_numtype1> > >
 
175
acosh(const Vector<P_numtype1>& d1)
 
176
{
 
177
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
178
        _bz_acosh<P_numtype1> > T_expr;
 
179
 
 
180
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
181
}
 
182
 
 
183
template<class P_expr1>
 
184
inline
 
185
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
186
    _bz_acosh<typename P_expr1::T_numtype> > >
 
187
acosh(_bz_VecExpr<P_expr1> d1)
 
188
{
 
189
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
190
        _bz_acosh<typename P_expr1::T_numtype> > T_expr;
 
191
 
 
192
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
193
}
 
194
 
 
195
template<class P_numtype1>
 
196
inline
 
197
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
198
    _bz_acosh<P_numtype1> > >
 
199
acosh(const VectorPick<P_numtype1>& d1)
 
200
{
 
201
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
202
        _bz_acosh<P_numtype1> > T_expr;
 
203
 
 
204
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
205
}
 
206
 
 
207
 
 
208
inline
 
209
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
210
    _bz_acosh<int> > >
 
211
acosh(Range d1)
 
212
{
 
213
    typedef _bz_VecExprUnaryOp<Range,
 
214
        _bz_acosh<int> > T_expr;
 
215
 
 
216
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
217
}
 
218
 
 
219
template<class P_numtype1, int N_length1>
 
220
inline
 
221
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
222
    _bz_acosh<P_numtype1> > >
 
223
acosh(const TinyVector<P_numtype1, N_length1>& d1)
 
224
{
 
225
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
226
        _bz_acosh<P_numtype1> > T_expr;
 
227
 
 
228
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
229
}
 
230
 
 
231
#endif
 
232
 
 
233
/****************************************************************************
 
234
 * asin
 
235
 ****************************************************************************/
 
236
 
 
237
template<class P_numtype1>
 
238
inline
 
239
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
240
    _bz_asin<P_numtype1> > >
 
241
asin(const Vector<P_numtype1>& d1)
 
242
{
 
243
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
244
        _bz_asin<P_numtype1> > T_expr;
 
245
 
 
246
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
247
}
 
248
 
 
249
template<class P_expr1>
 
250
inline
 
251
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
252
    _bz_asin<typename P_expr1::T_numtype> > >
 
253
asin(_bz_VecExpr<P_expr1> d1)
 
254
{
 
255
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
256
        _bz_asin<typename P_expr1::T_numtype> > T_expr;
 
257
 
 
258
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
259
}
 
260
 
 
261
template<class P_numtype1>
 
262
inline
 
263
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
264
    _bz_asin<P_numtype1> > >
 
265
asin(const VectorPick<P_numtype1>& d1)
 
266
{
 
267
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
268
        _bz_asin<P_numtype1> > T_expr;
 
269
 
 
270
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
271
}
 
272
 
 
273
 
 
274
inline
 
275
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
276
    _bz_asin<int> > >
 
277
asin(Range d1)
 
278
{
 
279
    typedef _bz_VecExprUnaryOp<Range,
 
280
        _bz_asin<int> > T_expr;
 
281
 
 
282
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
283
}
 
284
 
 
285
template<class P_numtype1, int N_length1>
 
286
inline
 
287
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
288
    _bz_asin<P_numtype1> > >
 
289
asin(const TinyVector<P_numtype1, N_length1>& d1)
 
290
{
 
291
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
292
        _bz_asin<P_numtype1> > T_expr;
 
293
 
 
294
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
295
}
 
296
 
 
297
 
 
298
/****************************************************************************
 
299
 * asinh
 
300
 ****************************************************************************/
 
301
 
 
302
#ifdef BZ_HAVE_IEEE_MATH
 
303
template<class P_numtype1>
 
304
inline
 
305
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
306
    _bz_asinh<P_numtype1> > >
 
307
asinh(const Vector<P_numtype1>& d1)
 
308
{
 
309
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
310
        _bz_asinh<P_numtype1> > T_expr;
 
311
 
 
312
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
313
}
 
314
 
 
315
template<class P_expr1>
 
316
inline
 
317
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
318
    _bz_asinh<typename P_expr1::T_numtype> > >
 
319
asinh(_bz_VecExpr<P_expr1> d1)
 
320
{
 
321
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
322
        _bz_asinh<typename P_expr1::T_numtype> > T_expr;
 
323
 
 
324
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
325
}
 
326
 
 
327
template<class P_numtype1>
 
328
inline
 
329
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
330
    _bz_asinh<P_numtype1> > >
 
331
asinh(const VectorPick<P_numtype1>& d1)
 
332
{
 
333
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
334
        _bz_asinh<P_numtype1> > T_expr;
 
335
 
 
336
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
337
}
 
338
 
 
339
 
 
340
inline
 
341
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
342
    _bz_asinh<int> > >
 
343
asinh(Range d1)
 
344
{
 
345
    typedef _bz_VecExprUnaryOp<Range,
 
346
        _bz_asinh<int> > T_expr;
 
347
 
 
348
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
349
}
 
350
 
 
351
template<class P_numtype1, int N_length1>
 
352
inline
 
353
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
354
    _bz_asinh<P_numtype1> > >
 
355
asinh(const TinyVector<P_numtype1, N_length1>& d1)
 
356
{
 
357
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
358
        _bz_asinh<P_numtype1> > T_expr;
 
359
 
 
360
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
361
}
 
362
 
 
363
#endif
 
364
 
 
365
/****************************************************************************
 
366
 * atan
 
367
 ****************************************************************************/
 
368
 
 
369
template<class P_numtype1>
 
370
inline
 
371
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
372
    _bz_atan<P_numtype1> > >
 
373
atan(const Vector<P_numtype1>& d1)
 
374
{
 
375
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
376
        _bz_atan<P_numtype1> > T_expr;
 
377
 
 
378
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
379
}
 
380
 
 
381
template<class P_expr1>
 
382
inline
 
383
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
384
    _bz_atan<typename P_expr1::T_numtype> > >
 
385
atan(_bz_VecExpr<P_expr1> d1)
 
386
{
 
387
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
388
        _bz_atan<typename P_expr1::T_numtype> > T_expr;
 
389
 
 
390
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
391
}
 
392
 
 
393
template<class P_numtype1>
 
394
inline
 
395
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
396
    _bz_atan<P_numtype1> > >
 
397
atan(const VectorPick<P_numtype1>& d1)
 
398
{
 
399
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
400
        _bz_atan<P_numtype1> > T_expr;
 
401
 
 
402
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
403
}
 
404
 
 
405
 
 
406
inline
 
407
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
408
    _bz_atan<int> > >
 
409
atan(Range d1)
 
410
{
 
411
    typedef _bz_VecExprUnaryOp<Range,
 
412
        _bz_atan<int> > T_expr;
 
413
 
 
414
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
415
}
 
416
 
 
417
template<class P_numtype1, int N_length1>
 
418
inline
 
419
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
420
    _bz_atan<P_numtype1> > >
 
421
atan(const TinyVector<P_numtype1, N_length1>& d1)
 
422
{
 
423
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
424
        _bz_atan<P_numtype1> > T_expr;
 
425
 
 
426
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
427
}
 
428
 
 
429
 
 
430
/****************************************************************************
 
431
 * atan2
 
432
 ****************************************************************************/
 
433
 
 
434
template<class P_numtype1, class P_numtype2>
 
435
inline
 
436
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
437
    _bz_atan2<P_numtype1,P_numtype2> > >
 
438
atan2(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
439
{
 
440
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
441
        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
 
442
 
 
443
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
444
}
 
445
 
 
446
template<class P_numtype1, class P_expr2>
 
447
inline
 
448
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
449
    _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > >
 
450
atan2(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
451
{
 
452
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
453
        _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
454
 
 
455
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
456
}
 
457
 
 
458
template<class P_numtype1, class P_numtype2>
 
459
inline
 
460
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
461
    _bz_atan2<P_numtype1,P_numtype2> > >
 
462
atan2(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
463
{
 
464
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
465
        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
 
466
 
 
467
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
468
}
 
469
 
 
470
template<class P_numtype1>
 
471
inline
 
472
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
473
    _bz_atan2<P_numtype1,int> > >
 
474
atan2(const Vector<P_numtype1>& d1, Range d2)
 
475
{
 
476
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
477
        _bz_atan2<P_numtype1,int> > T_expr;
 
478
 
 
479
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
480
}
 
481
 
 
482
template<class P_numtype1, class P_numtype2, int N_length2>
 
483
inline
 
484
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
485
    _bz_atan2<P_numtype1,P_numtype2> > >
 
486
atan2(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
487
{
 
488
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
489
        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
 
490
 
 
491
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
492
}
 
493
 
 
494
template<class P_numtype1>
 
495
inline
 
496
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
497
    _bz_atan2<P_numtype1,int> > >
 
498
atan2(const Vector<P_numtype1>& d1, int d2)
 
499
{
 
500
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
501
        _bz_atan2<P_numtype1,int> > T_expr;
 
502
 
 
503
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
504
}
 
505
 
 
506
template<class P_numtype1>
 
507
inline
 
508
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
509
    _bz_atan2<P_numtype1,float> > >
 
510
atan2(const Vector<P_numtype1>& d1, float d2)
 
511
{
 
512
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
513
        _bz_atan2<P_numtype1,float> > T_expr;
 
514
 
 
515
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
516
}
 
517
 
 
518
template<class P_numtype1>
 
519
inline
 
520
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
521
    _bz_atan2<P_numtype1,double> > >
 
522
atan2(const Vector<P_numtype1>& d1, double d2)
 
523
{
 
524
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
525
        _bz_atan2<P_numtype1,double> > T_expr;
 
526
 
 
527
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
528
}
 
529
 
 
530
template<class P_numtype1>
 
531
inline
 
532
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
533
    _bz_atan2<P_numtype1,long double> > >
 
534
atan2(const Vector<P_numtype1>& d1, long double d2)
 
535
{
 
536
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
537
        _bz_atan2<P_numtype1,long double> > T_expr;
 
538
 
 
539
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
540
}
 
541
 
 
542
template<class P_numtype1, class T2>
 
543
inline
 
544
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
545
    _bz_atan2<P_numtype1,complex<T2> > > >
 
546
atan2(const Vector<P_numtype1>& d1, complex<T2> d2)
 
547
{
 
548
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
549
        _bz_atan2<P_numtype1,complex<T2> > > T_expr;
 
550
 
 
551
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
552
}
 
553
 
 
554
template<class P_expr1, class P_numtype2>
 
555
inline
 
556
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
557
    _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > >
 
558
atan2(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
 
559
{
 
560
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
561
        _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
562
 
 
563
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
564
}
 
565
 
 
566
template<class P_expr1, class P_expr2>
 
567
inline
 
568
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
569
    _bz_atan2<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
 
570
atan2(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
 
571
{
 
572
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
573
        _bz_atan2<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
 
574
 
 
575
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
576
}
 
577
 
 
578
template<class P_expr1, class P_numtype2>
 
579
inline
 
580
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
581
    _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > >
 
582
atan2(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
 
583
{
 
584
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
585
        _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
586
 
 
587
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
588
}
 
589
 
 
590
template<class P_expr1>
 
591
inline
 
592
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
593
    _bz_atan2<typename P_expr1::T_numtype,int> > >
 
594
atan2(_bz_VecExpr<P_expr1> d1, Range d2)
 
595
{
 
596
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
597
        _bz_atan2<typename P_expr1::T_numtype,int> > T_expr;
 
598
 
 
599
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
600
}
 
601
 
 
602
template<class P_expr1, class P_numtype2, int N_length2>
 
603
inline
 
604
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
605
    _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > >
 
606
atan2(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
607
{
 
608
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
609
        _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
610
 
 
611
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
612
}
 
613
 
 
614
template<class P_expr1>
 
615
inline
 
616
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
617
    _bz_atan2<typename P_expr1::T_numtype,int> > >
 
618
atan2(_bz_VecExpr<P_expr1> d1, int d2)
 
619
{
 
620
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
621
        _bz_atan2<typename P_expr1::T_numtype,int> > T_expr;
 
622
 
 
623
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
624
}
 
625
 
 
626
template<class P_expr1>
 
627
inline
 
628
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
629
    _bz_atan2<typename P_expr1::T_numtype,float> > >
 
630
atan2(_bz_VecExpr<P_expr1> d1, float d2)
 
631
{
 
632
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
633
        _bz_atan2<typename P_expr1::T_numtype,float> > T_expr;
 
634
 
 
635
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
636
}
 
637
 
 
638
template<class P_expr1>
 
639
inline
 
640
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
641
    _bz_atan2<typename P_expr1::T_numtype,double> > >
 
642
atan2(_bz_VecExpr<P_expr1> d1, double d2)
 
643
{
 
644
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
645
        _bz_atan2<typename P_expr1::T_numtype,double> > T_expr;
 
646
 
 
647
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
648
}
 
649
 
 
650
template<class P_expr1>
 
651
inline
 
652
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
653
    _bz_atan2<typename P_expr1::T_numtype,long double> > >
 
654
atan2(_bz_VecExpr<P_expr1> d1, long double d2)
 
655
{
 
656
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
657
        _bz_atan2<typename P_expr1::T_numtype,long double> > T_expr;
 
658
 
 
659
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
660
}
 
661
 
 
662
template<class P_expr1, class T2>
 
663
inline
 
664
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
665
    _bz_atan2<typename P_expr1::T_numtype,complex<T2> > > >
 
666
atan2(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
 
667
{
 
668
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
669
        _bz_atan2<typename P_expr1::T_numtype,complex<T2> > > T_expr;
 
670
 
 
671
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
672
}
 
673
 
 
674
template<class P_numtype1, class P_numtype2>
 
675
inline
 
676
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
677
    _bz_atan2<P_numtype1,P_numtype2> > >
 
678
atan2(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
679
{
 
680
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
681
        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
 
682
 
 
683
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
684
}
 
685
 
 
686
template<class P_numtype1, class P_expr2>
 
687
inline
 
688
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
689
    _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > >
 
690
atan2(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
691
{
 
692
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
693
        _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
694
 
 
695
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
696
}
 
697
 
 
698
template<class P_numtype1, class P_numtype2>
 
699
inline
 
700
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
701
    _bz_atan2<P_numtype1,P_numtype2> > >
 
702
atan2(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
703
{
 
704
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
705
        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
 
706
 
 
707
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
708
}
 
709
 
 
710
template<class P_numtype1>
 
711
inline
 
712
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
713
    _bz_atan2<P_numtype1,int> > >
 
714
atan2(const VectorPick<P_numtype1>& d1, Range d2)
 
715
{
 
716
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
717
        _bz_atan2<P_numtype1,int> > T_expr;
 
718
 
 
719
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
720
}
 
721
 
 
722
template<class P_numtype1, class P_numtype2, int N_length2>
 
723
inline
 
724
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
725
    _bz_atan2<P_numtype1,P_numtype2> > >
 
726
atan2(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
727
{
 
728
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
729
        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
 
730
 
 
731
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
732
}
 
733
 
 
734
template<class P_numtype1>
 
735
inline
 
736
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
737
    _bz_atan2<P_numtype1,int> > >
 
738
atan2(const VectorPick<P_numtype1>& d1, int d2)
 
739
{
 
740
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
741
        _bz_atan2<P_numtype1,int> > T_expr;
 
742
 
 
743
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
744
}
 
745
 
 
746
template<class P_numtype1>
 
747
inline
 
748
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
749
    _bz_atan2<P_numtype1,float> > >
 
750
atan2(const VectorPick<P_numtype1>& d1, float d2)
 
751
{
 
752
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
753
        _bz_atan2<P_numtype1,float> > T_expr;
 
754
 
 
755
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
756
}
 
757
 
 
758
template<class P_numtype1>
 
759
inline
 
760
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
761
    _bz_atan2<P_numtype1,double> > >
 
762
atan2(const VectorPick<P_numtype1>& d1, double d2)
 
763
{
 
764
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
765
        _bz_atan2<P_numtype1,double> > T_expr;
 
766
 
 
767
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
768
}
 
769
 
 
770
template<class P_numtype1>
 
771
inline
 
772
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
773
    _bz_atan2<P_numtype1,long double> > >
 
774
atan2(const VectorPick<P_numtype1>& d1, long double d2)
 
775
{
 
776
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
777
        _bz_atan2<P_numtype1,long double> > T_expr;
 
778
 
 
779
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
780
}
 
781
 
 
782
template<class P_numtype1, class T2>
 
783
inline
 
784
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
785
    _bz_atan2<P_numtype1,complex<T2> > > >
 
786
atan2(const VectorPick<P_numtype1>& d1, complex<T2> d2)
 
787
{
 
788
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
789
        _bz_atan2<P_numtype1,complex<T2> > > T_expr;
 
790
 
 
791
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
792
}
 
793
 
 
794
template<class P_numtype2>
 
795
inline
 
796
_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
797
    _bz_atan2<int,P_numtype2> > >
 
798
atan2(Range d1, const Vector<P_numtype2>& d2)
 
799
{
 
800
    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
801
        _bz_atan2<int,P_numtype2> > T_expr;
 
802
 
 
803
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
804
}
 
805
 
 
806
template<class P_expr2>
 
807
inline
 
808
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
809
    _bz_atan2<int,typename P_expr2::T_numtype> > >
 
810
atan2(Range d1, _bz_VecExpr<P_expr2> d2)
 
811
{
 
812
    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
813
        _bz_atan2<int,typename P_expr2::T_numtype> > T_expr;
 
814
 
 
815
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
816
}
 
817
 
 
818
template<class P_numtype2>
 
819
inline
 
820
_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
821
    _bz_atan2<int,P_numtype2> > >
 
822
atan2(Range d1, const VectorPick<P_numtype2>& d2)
 
823
{
 
824
    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
825
        _bz_atan2<int,P_numtype2> > T_expr;
 
826
 
 
827
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
828
}
 
829
 
 
830
 
 
831
inline
 
832
_bz_VecExpr<_bz_VecExprOp<Range, Range,
 
833
    _bz_atan2<int,int> > >
 
834
atan2(Range d1, Range d2)
 
835
{
 
836
    typedef _bz_VecExprOp<Range, Range,
 
837
        _bz_atan2<int,int> > T_expr;
 
838
 
 
839
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
840
}
 
841
 
 
842
template<class P_numtype2, int N_length2>
 
843
inline
 
844
_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
845
    _bz_atan2<int,P_numtype2> > >
 
846
atan2(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
 
847
{
 
848
    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
849
        _bz_atan2<int,P_numtype2> > T_expr;
 
850
 
 
851
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
852
}
 
853
 
 
854
 
 
855
inline
 
856
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
857
    _bz_atan2<int,int> > >
 
858
atan2(Range d1, int d2)
 
859
{
 
860
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
861
        _bz_atan2<int,int> > T_expr;
 
862
 
 
863
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
864
}
 
865
 
 
866
 
 
867
inline
 
868
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
869
    _bz_atan2<int,float> > >
 
870
atan2(Range d1, float d2)
 
871
{
 
872
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
873
        _bz_atan2<int,float> > T_expr;
 
874
 
 
875
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
876
}
 
877
 
 
878
 
 
879
inline
 
880
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
881
    _bz_atan2<int,double> > >
 
882
atan2(Range d1, double d2)
 
883
{
 
884
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
885
        _bz_atan2<int,double> > T_expr;
 
886
 
 
887
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
888
}
 
889
 
 
890
 
 
891
inline
 
892
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
893
    _bz_atan2<int,long double> > >
 
894
atan2(Range d1, long double d2)
 
895
{
 
896
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
897
        _bz_atan2<int,long double> > T_expr;
 
898
 
 
899
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
900
}
 
901
 
 
902
template<class T2>
 
903
inline
 
904
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
905
    _bz_atan2<int,complex<T2> > > >
 
906
atan2(Range d1, complex<T2> d2)
 
907
{
 
908
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
909
        _bz_atan2<int,complex<T2> > > T_expr;
 
910
 
 
911
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
912
}
 
913
 
 
914
template<class P_numtype1, int N_length1, class P_numtype2>
 
915
inline
 
916
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
917
    _bz_atan2<P_numtype1,P_numtype2> > >
 
918
atan2(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
 
919
{
 
920
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
921
        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
 
922
 
 
923
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
924
}
 
925
 
 
926
template<class P_numtype1, int N_length1, class P_expr2>
 
927
inline
 
928
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
929
    _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > >
 
930
atan2(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
 
931
{
 
932
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
933
        _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
934
 
 
935
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
936
}
 
937
 
 
938
template<class P_numtype1, int N_length1, class P_numtype2>
 
939
inline
 
940
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
941
    _bz_atan2<P_numtype1,P_numtype2> > >
 
942
atan2(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
 
943
{
 
944
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
945
        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
 
946
 
 
947
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
948
}
 
949
 
 
950
template<class P_numtype1, int N_length1>
 
951
inline
 
952
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
953
    _bz_atan2<P_numtype1,int> > >
 
954
atan2(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
 
955
{
 
956
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
957
        _bz_atan2<P_numtype1,int> > T_expr;
 
958
 
 
959
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
960
}
 
961
 
 
962
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
 
963
inline
 
964
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
965
    _bz_atan2<P_numtype1,P_numtype2> > >
 
966
atan2(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
967
{
 
968
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
969
        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
 
970
 
 
971
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
972
}
 
973
 
 
974
template<class P_numtype1, int N_length1>
 
975
inline
 
976
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
977
    _bz_atan2<P_numtype1,int> > >
 
978
atan2(const TinyVector<P_numtype1, N_length1>& d1, int d2)
 
979
{
 
980
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
981
        _bz_atan2<P_numtype1,int> > T_expr;
 
982
 
 
983
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
984
}
 
985
 
 
986
template<class P_numtype1, int N_length1>
 
987
inline
 
988
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
989
    _bz_atan2<P_numtype1,float> > >
 
990
atan2(const TinyVector<P_numtype1, N_length1>& d1, float d2)
 
991
{
 
992
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
993
        _bz_atan2<P_numtype1,float> > T_expr;
 
994
 
 
995
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
996
}
 
997
 
 
998
template<class P_numtype1, int N_length1>
 
999
inline
 
1000
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
1001
    _bz_atan2<P_numtype1,double> > >
 
1002
atan2(const TinyVector<P_numtype1, N_length1>& d1, double d2)
 
1003
{
 
1004
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
1005
        _bz_atan2<P_numtype1,double> > T_expr;
 
1006
 
 
1007
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
1008
}
 
1009
 
 
1010
template<class P_numtype1, int N_length1>
 
1011
inline
 
1012
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
1013
    _bz_atan2<P_numtype1,long double> > >
 
1014
atan2(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
 
1015
{
 
1016
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
1017
        _bz_atan2<P_numtype1,long double> > T_expr;
 
1018
 
 
1019
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
1020
}
 
1021
 
 
1022
template<class P_numtype1, int N_length1, class T2>
 
1023
inline
 
1024
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
1025
    _bz_atan2<P_numtype1,complex<T2> > > >
 
1026
atan2(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
 
1027
{
 
1028
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
1029
        _bz_atan2<P_numtype1,complex<T2> > > T_expr;
 
1030
 
 
1031
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
1032
}
 
1033
 
 
1034
template<class P_numtype2>
 
1035
inline
 
1036
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
1037
    _bz_atan2<int,P_numtype2> > >
 
1038
atan2(int d1, const Vector<P_numtype2>& d2)
 
1039
{
 
1040
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
1041
        _bz_atan2<int,P_numtype2> > T_expr;
 
1042
 
 
1043
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
1044
}
 
1045
 
 
1046
template<class P_expr2>
 
1047
inline
 
1048
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
1049
    _bz_atan2<int,typename P_expr2::T_numtype> > >
 
1050
atan2(int d1, _bz_VecExpr<P_expr2> d2)
 
1051
{
 
1052
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
1053
        _bz_atan2<int,typename P_expr2::T_numtype> > T_expr;
 
1054
 
 
1055
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
1056
}
 
1057
 
 
1058
template<class P_numtype2>
 
1059
inline
 
1060
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
1061
    _bz_atan2<int,P_numtype2> > >
 
1062
atan2(int d1, const VectorPick<P_numtype2>& d2)
 
1063
{
 
1064
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
1065
        _bz_atan2<int,P_numtype2> > T_expr;
 
1066
 
 
1067
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
1068
}
 
1069
 
 
1070
 
 
1071
inline
 
1072
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
1073
    _bz_atan2<int,int> > >
 
1074
atan2(int d1, Range d2)
 
1075
{
 
1076
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
1077
        _bz_atan2<int,int> > T_expr;
 
1078
 
 
1079
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
1080
}
 
1081
 
 
1082
template<class P_numtype2, int N_length2>
 
1083
inline
 
1084
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1085
    _bz_atan2<int,P_numtype2> > >
 
1086
atan2(int d1, const TinyVector<P_numtype2, N_length2>& d2)
 
1087
{
 
1088
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1089
        _bz_atan2<int,P_numtype2> > T_expr;
 
1090
 
 
1091
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
1092
}
 
1093
 
 
1094
template<class P_numtype2>
 
1095
inline
 
1096
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
1097
    _bz_atan2<float,P_numtype2> > >
 
1098
atan2(float d1, const Vector<P_numtype2>& d2)
 
1099
{
 
1100
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
1101
        _bz_atan2<float,P_numtype2> > T_expr;
 
1102
 
 
1103
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
1104
}
 
1105
 
 
1106
template<class P_expr2>
 
1107
inline
 
1108
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
1109
    _bz_atan2<float,typename P_expr2::T_numtype> > >
 
1110
atan2(float d1, _bz_VecExpr<P_expr2> d2)
 
1111
{
 
1112
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
1113
        _bz_atan2<float,typename P_expr2::T_numtype> > T_expr;
 
1114
 
 
1115
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
1116
}
 
1117
 
 
1118
template<class P_numtype2>
 
1119
inline
 
1120
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
1121
    _bz_atan2<float,P_numtype2> > >
 
1122
atan2(float d1, const VectorPick<P_numtype2>& d2)
 
1123
{
 
1124
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
1125
        _bz_atan2<float,P_numtype2> > T_expr;
 
1126
 
 
1127
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
1128
}
 
1129
 
 
1130
 
 
1131
inline
 
1132
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
1133
    _bz_atan2<float,int> > >
 
1134
atan2(float d1, Range d2)
 
1135
{
 
1136
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
1137
        _bz_atan2<float,int> > T_expr;
 
1138
 
 
1139
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
1140
}
 
1141
 
 
1142
template<class P_numtype2, int N_length2>
 
1143
inline
 
1144
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1145
    _bz_atan2<float,P_numtype2> > >
 
1146
atan2(float d1, const TinyVector<P_numtype2, N_length2>& d2)
 
1147
{
 
1148
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1149
        _bz_atan2<float,P_numtype2> > T_expr;
 
1150
 
 
1151
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
1152
}
 
1153
 
 
1154
template<class P_numtype2>
 
1155
inline
 
1156
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
1157
    _bz_atan2<double,P_numtype2> > >
 
1158
atan2(double d1, const Vector<P_numtype2>& d2)
 
1159
{
 
1160
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
1161
        _bz_atan2<double,P_numtype2> > T_expr;
 
1162
 
 
1163
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
1164
}
 
1165
 
 
1166
template<class P_expr2>
 
1167
inline
 
1168
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
1169
    _bz_atan2<double,typename P_expr2::T_numtype> > >
 
1170
atan2(double d1, _bz_VecExpr<P_expr2> d2)
 
1171
{
 
1172
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
1173
        _bz_atan2<double,typename P_expr2::T_numtype> > T_expr;
 
1174
 
 
1175
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
1176
}
 
1177
 
 
1178
template<class P_numtype2>
 
1179
inline
 
1180
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
1181
    _bz_atan2<double,P_numtype2> > >
 
1182
atan2(double d1, const VectorPick<P_numtype2>& d2)
 
1183
{
 
1184
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
1185
        _bz_atan2<double,P_numtype2> > T_expr;
 
1186
 
 
1187
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
1188
}
 
1189
 
 
1190
 
 
1191
inline
 
1192
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
1193
    _bz_atan2<double,int> > >
 
1194
atan2(double d1, Range d2)
 
1195
{
 
1196
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
1197
        _bz_atan2<double,int> > T_expr;
 
1198
 
 
1199
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
1200
}
 
1201
 
 
1202
template<class P_numtype2, int N_length2>
 
1203
inline
 
1204
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1205
    _bz_atan2<double,P_numtype2> > >
 
1206
atan2(double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
1207
{
 
1208
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1209
        _bz_atan2<double,P_numtype2> > T_expr;
 
1210
 
 
1211
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
1212
}
 
1213
 
 
1214
template<class P_numtype2>
 
1215
inline
 
1216
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
1217
    _bz_atan2<long double,P_numtype2> > >
 
1218
atan2(long double d1, const Vector<P_numtype2>& d2)
 
1219
{
 
1220
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
1221
        _bz_atan2<long double,P_numtype2> > T_expr;
 
1222
 
 
1223
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
1224
}
 
1225
 
 
1226
template<class P_expr2>
 
1227
inline
 
1228
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
1229
    _bz_atan2<long double,typename P_expr2::T_numtype> > >
 
1230
atan2(long double d1, _bz_VecExpr<P_expr2> d2)
 
1231
{
 
1232
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
1233
        _bz_atan2<long double,typename P_expr2::T_numtype> > T_expr;
 
1234
 
 
1235
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
1236
}
 
1237
 
 
1238
template<class P_numtype2>
 
1239
inline
 
1240
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
1241
    _bz_atan2<long double,P_numtype2> > >
 
1242
atan2(long double d1, const VectorPick<P_numtype2>& d2)
 
1243
{
 
1244
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
1245
        _bz_atan2<long double,P_numtype2> > T_expr;
 
1246
 
 
1247
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
1248
}
 
1249
 
 
1250
 
 
1251
inline
 
1252
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
1253
    _bz_atan2<long double,int> > >
 
1254
atan2(long double d1, Range d2)
 
1255
{
 
1256
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
1257
        _bz_atan2<long double,int> > T_expr;
 
1258
 
 
1259
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
1260
}
 
1261
 
 
1262
template<class P_numtype2, int N_length2>
 
1263
inline
 
1264
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1265
    _bz_atan2<long double,P_numtype2> > >
 
1266
atan2(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
1267
{
 
1268
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1269
        _bz_atan2<long double,P_numtype2> > T_expr;
 
1270
 
 
1271
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
1272
}
 
1273
 
 
1274
template<class T1, class P_numtype2>
 
1275
inline
 
1276
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
1277
    _bz_atan2<complex<T1> ,P_numtype2> > >
 
1278
atan2(complex<T1> d1, const Vector<P_numtype2>& d2)
 
1279
{
 
1280
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
1281
        _bz_atan2<complex<T1> ,P_numtype2> > T_expr;
 
1282
 
 
1283
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
1284
}
 
1285
 
 
1286
template<class T1, class P_expr2>
 
1287
inline
 
1288
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
1289
    _bz_atan2<complex<T1> ,typename P_expr2::T_numtype> > >
 
1290
atan2(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
 
1291
{
 
1292
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
1293
        _bz_atan2<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
 
1294
 
 
1295
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
1296
}
 
1297
 
 
1298
template<class T1, class P_numtype2>
 
1299
inline
 
1300
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
1301
    _bz_atan2<complex<T1> ,P_numtype2> > >
 
1302
atan2(complex<T1> d1, const VectorPick<P_numtype2>& d2)
 
1303
{
 
1304
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
1305
        _bz_atan2<complex<T1> ,P_numtype2> > T_expr;
 
1306
 
 
1307
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
1308
}
 
1309
 
 
1310
template<class T1>
 
1311
inline
 
1312
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
1313
    _bz_atan2<complex<T1> ,int> > >
 
1314
atan2(complex<T1> d1, Range d2)
 
1315
{
 
1316
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
1317
        _bz_atan2<complex<T1> ,int> > T_expr;
 
1318
 
 
1319
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
1320
}
 
1321
 
 
1322
template<class T1, class P_numtype2, int N_length2>
 
1323
inline
 
1324
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
1325
    _bz_atan2<complex<T1> ,P_numtype2> > >
 
1326
atan2(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
1327
{
 
1328
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
1329
        _bz_atan2<complex<T1> ,P_numtype2> > T_expr;
 
1330
 
 
1331
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
1332
}
 
1333
 
 
1334
 
 
1335
/****************************************************************************
 
1336
 * atanh
 
1337
 ****************************************************************************/
 
1338
 
 
1339
#ifdef BZ_HAVE_IEEE_MATH
 
1340
template<class P_numtype1>
 
1341
inline
 
1342
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
1343
    _bz_atanh<P_numtype1> > >
 
1344
atanh(const Vector<P_numtype1>& d1)
 
1345
{
 
1346
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
1347
        _bz_atanh<P_numtype1> > T_expr;
 
1348
 
 
1349
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1350
}
 
1351
 
 
1352
template<class P_expr1>
 
1353
inline
 
1354
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
1355
    _bz_atanh<typename P_expr1::T_numtype> > >
 
1356
atanh(_bz_VecExpr<P_expr1> d1)
 
1357
{
 
1358
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
1359
        _bz_atanh<typename P_expr1::T_numtype> > T_expr;
 
1360
 
 
1361
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
1362
}
 
1363
 
 
1364
template<class P_numtype1>
 
1365
inline
 
1366
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
1367
    _bz_atanh<P_numtype1> > >
 
1368
atanh(const VectorPick<P_numtype1>& d1)
 
1369
{
 
1370
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
1371
        _bz_atanh<P_numtype1> > T_expr;
 
1372
 
 
1373
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1374
}
 
1375
 
 
1376
 
 
1377
inline
 
1378
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
1379
    _bz_atanh<int> > >
 
1380
atanh(Range d1)
 
1381
{
 
1382
    typedef _bz_VecExprUnaryOp<Range,
 
1383
        _bz_atanh<int> > T_expr;
 
1384
 
 
1385
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
1386
}
 
1387
 
 
1388
template<class P_numtype1, int N_length1>
 
1389
inline
 
1390
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
1391
    _bz_atanh<P_numtype1> > >
 
1392
atanh(const TinyVector<P_numtype1, N_length1>& d1)
 
1393
{
 
1394
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
1395
        _bz_atanh<P_numtype1> > T_expr;
 
1396
 
 
1397
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1398
}
 
1399
 
 
1400
#endif
 
1401
 
 
1402
/****************************************************************************
 
1403
 * _class
 
1404
 ****************************************************************************/
 
1405
 
 
1406
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
1407
template<class P_numtype1>
 
1408
inline
 
1409
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
1410
    _bz__class<P_numtype1> > >
 
1411
_class(const Vector<P_numtype1>& d1)
 
1412
{
 
1413
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
1414
        _bz__class<P_numtype1> > T_expr;
 
1415
 
 
1416
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1417
}
 
1418
 
 
1419
template<class P_expr1>
 
1420
inline
 
1421
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
1422
    _bz__class<typename P_expr1::T_numtype> > >
 
1423
_class(_bz_VecExpr<P_expr1> d1)
 
1424
{
 
1425
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
1426
        _bz__class<typename P_expr1::T_numtype> > T_expr;
 
1427
 
 
1428
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
1429
}
 
1430
 
 
1431
template<class P_numtype1>
 
1432
inline
 
1433
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
1434
    _bz__class<P_numtype1> > >
 
1435
_class(const VectorPick<P_numtype1>& d1)
 
1436
{
 
1437
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
1438
        _bz__class<P_numtype1> > T_expr;
 
1439
 
 
1440
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1441
}
 
1442
 
 
1443
 
 
1444
inline
 
1445
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
1446
    _bz__class<int> > >
 
1447
_class(Range d1)
 
1448
{
 
1449
    typedef _bz_VecExprUnaryOp<Range,
 
1450
        _bz__class<int> > T_expr;
 
1451
 
 
1452
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
1453
}
 
1454
 
 
1455
template<class P_numtype1, int N_length1>
 
1456
inline
 
1457
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
1458
    _bz__class<P_numtype1> > >
 
1459
_class(const TinyVector<P_numtype1, N_length1>& d1)
 
1460
{
 
1461
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
1462
        _bz__class<P_numtype1> > T_expr;
 
1463
 
 
1464
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1465
}
 
1466
 
 
1467
#endif
 
1468
 
 
1469
/****************************************************************************
 
1470
 * cbrt
 
1471
 ****************************************************************************/
 
1472
 
 
1473
#ifdef BZ_HAVE_IEEE_MATH
 
1474
template<class P_numtype1>
 
1475
inline
 
1476
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
1477
    _bz_cbrt<P_numtype1> > >
 
1478
cbrt(const Vector<P_numtype1>& d1)
 
1479
{
 
1480
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
1481
        _bz_cbrt<P_numtype1> > T_expr;
 
1482
 
 
1483
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1484
}
 
1485
 
 
1486
template<class P_expr1>
 
1487
inline
 
1488
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
1489
    _bz_cbrt<typename P_expr1::T_numtype> > >
 
1490
cbrt(_bz_VecExpr<P_expr1> d1)
 
1491
{
 
1492
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
1493
        _bz_cbrt<typename P_expr1::T_numtype> > T_expr;
 
1494
 
 
1495
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
1496
}
 
1497
 
 
1498
template<class P_numtype1>
 
1499
inline
 
1500
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
1501
    _bz_cbrt<P_numtype1> > >
 
1502
cbrt(const VectorPick<P_numtype1>& d1)
 
1503
{
 
1504
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
1505
        _bz_cbrt<P_numtype1> > T_expr;
 
1506
 
 
1507
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1508
}
 
1509
 
 
1510
 
 
1511
inline
 
1512
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
1513
    _bz_cbrt<int> > >
 
1514
cbrt(Range d1)
 
1515
{
 
1516
    typedef _bz_VecExprUnaryOp<Range,
 
1517
        _bz_cbrt<int> > T_expr;
 
1518
 
 
1519
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
1520
}
 
1521
 
 
1522
template<class P_numtype1, int N_length1>
 
1523
inline
 
1524
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
1525
    _bz_cbrt<P_numtype1> > >
 
1526
cbrt(const TinyVector<P_numtype1, N_length1>& d1)
 
1527
{
 
1528
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
1529
        _bz_cbrt<P_numtype1> > T_expr;
 
1530
 
 
1531
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1532
}
 
1533
 
 
1534
#endif
 
1535
 
 
1536
/****************************************************************************
 
1537
 * ceil
 
1538
 ****************************************************************************/
 
1539
 
 
1540
template<class P_numtype1>
 
1541
inline
 
1542
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
1543
    _bz_ceil<P_numtype1> > >
 
1544
ceil(const Vector<P_numtype1>& d1)
 
1545
{
 
1546
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
1547
        _bz_ceil<P_numtype1> > T_expr;
 
1548
 
 
1549
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1550
}
 
1551
 
 
1552
template<class P_expr1>
 
1553
inline
 
1554
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
1555
    _bz_ceil<typename P_expr1::T_numtype> > >
 
1556
ceil(_bz_VecExpr<P_expr1> d1)
 
1557
{
 
1558
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
1559
        _bz_ceil<typename P_expr1::T_numtype> > T_expr;
 
1560
 
 
1561
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
1562
}
 
1563
 
 
1564
template<class P_numtype1>
 
1565
inline
 
1566
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
1567
    _bz_ceil<P_numtype1> > >
 
1568
ceil(const VectorPick<P_numtype1>& d1)
 
1569
{
 
1570
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
1571
        _bz_ceil<P_numtype1> > T_expr;
 
1572
 
 
1573
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1574
}
 
1575
 
 
1576
 
 
1577
inline
 
1578
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
1579
    _bz_ceil<int> > >
 
1580
ceil(Range d1)
 
1581
{
 
1582
    typedef _bz_VecExprUnaryOp<Range,
 
1583
        _bz_ceil<int> > T_expr;
 
1584
 
 
1585
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
1586
}
 
1587
 
 
1588
template<class P_numtype1, int N_length1>
 
1589
inline
 
1590
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
1591
    _bz_ceil<P_numtype1> > >
 
1592
ceil(const TinyVector<P_numtype1, N_length1>& d1)
 
1593
{
 
1594
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
1595
        _bz_ceil<P_numtype1> > T_expr;
 
1596
 
 
1597
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1598
}
 
1599
 
 
1600
 
 
1601
/****************************************************************************
 
1602
 * conj
 
1603
 ****************************************************************************/
 
1604
 
 
1605
#ifdef BZ_HAVE_COMPLEX_FCNS
 
1606
template<class P_numtype1>
 
1607
inline
 
1608
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
1609
    _bz_conj<P_numtype1> > >
 
1610
conj(const Vector<P_numtype1>& d1)
 
1611
{
 
1612
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
1613
        _bz_conj<P_numtype1> > T_expr;
 
1614
 
 
1615
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1616
}
 
1617
 
 
1618
template<class P_expr1>
 
1619
inline
 
1620
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
1621
    _bz_conj<typename P_expr1::T_numtype> > >
 
1622
conj(_bz_VecExpr<P_expr1> d1)
 
1623
{
 
1624
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
1625
        _bz_conj<typename P_expr1::T_numtype> > T_expr;
 
1626
 
 
1627
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
1628
}
 
1629
 
 
1630
template<class P_numtype1>
 
1631
inline
 
1632
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
1633
    _bz_conj<P_numtype1> > >
 
1634
conj(const VectorPick<P_numtype1>& d1)
 
1635
{
 
1636
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
1637
        _bz_conj<P_numtype1> > T_expr;
 
1638
 
 
1639
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1640
}
 
1641
 
 
1642
 
 
1643
inline
 
1644
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
1645
    _bz_conj<int> > >
 
1646
conj(Range d1)
 
1647
{
 
1648
    typedef _bz_VecExprUnaryOp<Range,
 
1649
        _bz_conj<int> > T_expr;
 
1650
 
 
1651
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
1652
}
 
1653
 
 
1654
template<class P_numtype1, int N_length1>
 
1655
inline
 
1656
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
1657
    _bz_conj<P_numtype1> > >
 
1658
conj(const TinyVector<P_numtype1, N_length1>& d1)
 
1659
{
 
1660
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
1661
        _bz_conj<P_numtype1> > T_expr;
 
1662
 
 
1663
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
1664
}
 
1665
 
 
1666
#endif
 
1667
 
 
1668
/****************************************************************************
 
1669
 * copysign
 
1670
 ****************************************************************************/
 
1671
 
 
1672
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
1673
template<class P_numtype1, class P_numtype2>
 
1674
inline
 
1675
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
1676
    _bz_copysign<P_numtype1,P_numtype2> > >
 
1677
copysign(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
1678
{
 
1679
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
1680
        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
 
1681
 
 
1682
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
1683
}
 
1684
 
 
1685
template<class P_numtype1, class P_expr2>
 
1686
inline
 
1687
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
1688
    _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > >
 
1689
copysign(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
1690
{
 
1691
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
1692
        _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
1693
 
 
1694
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
1695
}
 
1696
 
 
1697
template<class P_numtype1, class P_numtype2>
 
1698
inline
 
1699
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
1700
    _bz_copysign<P_numtype1,P_numtype2> > >
 
1701
copysign(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
1702
{
 
1703
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
1704
        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
 
1705
 
 
1706
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
1707
}
 
1708
 
 
1709
template<class P_numtype1>
 
1710
inline
 
1711
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
1712
    _bz_copysign<P_numtype1,int> > >
 
1713
copysign(const Vector<P_numtype1>& d1, Range d2)
 
1714
{
 
1715
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
1716
        _bz_copysign<P_numtype1,int> > T_expr;
 
1717
 
 
1718
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
1719
}
 
1720
 
 
1721
template<class P_numtype1, class P_numtype2, int N_length2>
 
1722
inline
 
1723
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1724
    _bz_copysign<P_numtype1,P_numtype2> > >
 
1725
copysign(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
1726
{
 
1727
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1728
        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
 
1729
 
 
1730
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
1731
}
 
1732
 
 
1733
template<class P_numtype1>
 
1734
inline
 
1735
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
1736
    _bz_copysign<P_numtype1,int> > >
 
1737
copysign(const Vector<P_numtype1>& d1, int d2)
 
1738
{
 
1739
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
1740
        _bz_copysign<P_numtype1,int> > T_expr;
 
1741
 
 
1742
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
1743
}
 
1744
 
 
1745
template<class P_numtype1>
 
1746
inline
 
1747
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
1748
    _bz_copysign<P_numtype1,float> > >
 
1749
copysign(const Vector<P_numtype1>& d1, float d2)
 
1750
{
 
1751
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
1752
        _bz_copysign<P_numtype1,float> > T_expr;
 
1753
 
 
1754
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
1755
}
 
1756
 
 
1757
template<class P_numtype1>
 
1758
inline
 
1759
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
1760
    _bz_copysign<P_numtype1,double> > >
 
1761
copysign(const Vector<P_numtype1>& d1, double d2)
 
1762
{
 
1763
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
1764
        _bz_copysign<P_numtype1,double> > T_expr;
 
1765
 
 
1766
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
1767
}
 
1768
 
 
1769
template<class P_numtype1>
 
1770
inline
 
1771
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
1772
    _bz_copysign<P_numtype1,long double> > >
 
1773
copysign(const Vector<P_numtype1>& d1, long double d2)
 
1774
{
 
1775
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
1776
        _bz_copysign<P_numtype1,long double> > T_expr;
 
1777
 
 
1778
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
1779
}
 
1780
 
 
1781
template<class P_numtype1, class T2>
 
1782
inline
 
1783
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
1784
    _bz_copysign<P_numtype1,complex<T2> > > >
 
1785
copysign(const Vector<P_numtype1>& d1, complex<T2> d2)
 
1786
{
 
1787
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
1788
        _bz_copysign<P_numtype1,complex<T2> > > T_expr;
 
1789
 
 
1790
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
1791
}
 
1792
 
 
1793
template<class P_expr1, class P_numtype2>
 
1794
inline
 
1795
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
1796
    _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > >
 
1797
copysign(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
 
1798
{
 
1799
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
1800
        _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
1801
 
 
1802
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
1803
}
 
1804
 
 
1805
template<class P_expr1, class P_expr2>
 
1806
inline
 
1807
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
1808
    _bz_copysign<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
 
1809
copysign(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
 
1810
{
 
1811
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
1812
        _bz_copysign<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
 
1813
 
 
1814
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
1815
}
 
1816
 
 
1817
template<class P_expr1, class P_numtype2>
 
1818
inline
 
1819
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
1820
    _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > >
 
1821
copysign(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
 
1822
{
 
1823
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
1824
        _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
1825
 
 
1826
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
1827
}
 
1828
 
 
1829
template<class P_expr1>
 
1830
inline
 
1831
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
1832
    _bz_copysign<typename P_expr1::T_numtype,int> > >
 
1833
copysign(_bz_VecExpr<P_expr1> d1, Range d2)
 
1834
{
 
1835
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
1836
        _bz_copysign<typename P_expr1::T_numtype,int> > T_expr;
 
1837
 
 
1838
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
1839
}
 
1840
 
 
1841
template<class P_expr1, class P_numtype2, int N_length2>
 
1842
inline
 
1843
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1844
    _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > >
 
1845
copysign(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
1846
{
 
1847
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1848
        _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
1849
 
 
1850
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
1851
}
 
1852
 
 
1853
template<class P_expr1>
 
1854
inline
 
1855
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
1856
    _bz_copysign<typename P_expr1::T_numtype,int> > >
 
1857
copysign(_bz_VecExpr<P_expr1> d1, int d2)
 
1858
{
 
1859
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
1860
        _bz_copysign<typename P_expr1::T_numtype,int> > T_expr;
 
1861
 
 
1862
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
1863
}
 
1864
 
 
1865
template<class P_expr1>
 
1866
inline
 
1867
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
1868
    _bz_copysign<typename P_expr1::T_numtype,float> > >
 
1869
copysign(_bz_VecExpr<P_expr1> d1, float d2)
 
1870
{
 
1871
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
1872
        _bz_copysign<typename P_expr1::T_numtype,float> > T_expr;
 
1873
 
 
1874
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
1875
}
 
1876
 
 
1877
template<class P_expr1>
 
1878
inline
 
1879
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
1880
    _bz_copysign<typename P_expr1::T_numtype,double> > >
 
1881
copysign(_bz_VecExpr<P_expr1> d1, double d2)
 
1882
{
 
1883
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
1884
        _bz_copysign<typename P_expr1::T_numtype,double> > T_expr;
 
1885
 
 
1886
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
1887
}
 
1888
 
 
1889
template<class P_expr1>
 
1890
inline
 
1891
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
1892
    _bz_copysign<typename P_expr1::T_numtype,long double> > >
 
1893
copysign(_bz_VecExpr<P_expr1> d1, long double d2)
 
1894
{
 
1895
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
1896
        _bz_copysign<typename P_expr1::T_numtype,long double> > T_expr;
 
1897
 
 
1898
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
1899
}
 
1900
 
 
1901
template<class P_expr1, class T2>
 
1902
inline
 
1903
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
1904
    _bz_copysign<typename P_expr1::T_numtype,complex<T2> > > >
 
1905
copysign(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
 
1906
{
 
1907
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
1908
        _bz_copysign<typename P_expr1::T_numtype,complex<T2> > > T_expr;
 
1909
 
 
1910
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
1911
}
 
1912
 
 
1913
template<class P_numtype1, class P_numtype2>
 
1914
inline
 
1915
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
1916
    _bz_copysign<P_numtype1,P_numtype2> > >
 
1917
copysign(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
1918
{
 
1919
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
1920
        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
 
1921
 
 
1922
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
1923
}
 
1924
 
 
1925
template<class P_numtype1, class P_expr2>
 
1926
inline
 
1927
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
1928
    _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > >
 
1929
copysign(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
1930
{
 
1931
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
1932
        _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
1933
 
 
1934
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
1935
}
 
1936
 
 
1937
template<class P_numtype1, class P_numtype2>
 
1938
inline
 
1939
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
1940
    _bz_copysign<P_numtype1,P_numtype2> > >
 
1941
copysign(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
1942
{
 
1943
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
1944
        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
 
1945
 
 
1946
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
1947
}
 
1948
 
 
1949
template<class P_numtype1>
 
1950
inline
 
1951
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
1952
    _bz_copysign<P_numtype1,int> > >
 
1953
copysign(const VectorPick<P_numtype1>& d1, Range d2)
 
1954
{
 
1955
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
1956
        _bz_copysign<P_numtype1,int> > T_expr;
 
1957
 
 
1958
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
1959
}
 
1960
 
 
1961
template<class P_numtype1, class P_numtype2, int N_length2>
 
1962
inline
 
1963
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1964
    _bz_copysign<P_numtype1,P_numtype2> > >
 
1965
copysign(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
1966
{
 
1967
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
1968
        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
 
1969
 
 
1970
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
1971
}
 
1972
 
 
1973
template<class P_numtype1>
 
1974
inline
 
1975
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
1976
    _bz_copysign<P_numtype1,int> > >
 
1977
copysign(const VectorPick<P_numtype1>& d1, int d2)
 
1978
{
 
1979
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
1980
        _bz_copysign<P_numtype1,int> > T_expr;
 
1981
 
 
1982
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
1983
}
 
1984
 
 
1985
template<class P_numtype1>
 
1986
inline
 
1987
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
1988
    _bz_copysign<P_numtype1,float> > >
 
1989
copysign(const VectorPick<P_numtype1>& d1, float d2)
 
1990
{
 
1991
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
1992
        _bz_copysign<P_numtype1,float> > T_expr;
 
1993
 
 
1994
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
1995
}
 
1996
 
 
1997
template<class P_numtype1>
 
1998
inline
 
1999
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
2000
    _bz_copysign<P_numtype1,double> > >
 
2001
copysign(const VectorPick<P_numtype1>& d1, double d2)
 
2002
{
 
2003
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
2004
        _bz_copysign<P_numtype1,double> > T_expr;
 
2005
 
 
2006
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
2007
}
 
2008
 
 
2009
template<class P_numtype1>
 
2010
inline
 
2011
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
2012
    _bz_copysign<P_numtype1,long double> > >
 
2013
copysign(const VectorPick<P_numtype1>& d1, long double d2)
 
2014
{
 
2015
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
2016
        _bz_copysign<P_numtype1,long double> > T_expr;
 
2017
 
 
2018
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
2019
}
 
2020
 
 
2021
template<class P_numtype1, class T2>
 
2022
inline
 
2023
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
2024
    _bz_copysign<P_numtype1,complex<T2> > > >
 
2025
copysign(const VectorPick<P_numtype1>& d1, complex<T2> d2)
 
2026
{
 
2027
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
2028
        _bz_copysign<P_numtype1,complex<T2> > > T_expr;
 
2029
 
 
2030
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
2031
}
 
2032
 
 
2033
template<class P_numtype2>
 
2034
inline
 
2035
_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
2036
    _bz_copysign<int,P_numtype2> > >
 
2037
copysign(Range d1, const Vector<P_numtype2>& d2)
 
2038
{
 
2039
    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
2040
        _bz_copysign<int,P_numtype2> > T_expr;
 
2041
 
 
2042
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
2043
}
 
2044
 
 
2045
template<class P_expr2>
 
2046
inline
 
2047
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
2048
    _bz_copysign<int,typename P_expr2::T_numtype> > >
 
2049
copysign(Range d1, _bz_VecExpr<P_expr2> d2)
 
2050
{
 
2051
    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
2052
        _bz_copysign<int,typename P_expr2::T_numtype> > T_expr;
 
2053
 
 
2054
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
2055
}
 
2056
 
 
2057
template<class P_numtype2>
 
2058
inline
 
2059
_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
2060
    _bz_copysign<int,P_numtype2> > >
 
2061
copysign(Range d1, const VectorPick<P_numtype2>& d2)
 
2062
{
 
2063
    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
2064
        _bz_copysign<int,P_numtype2> > T_expr;
 
2065
 
 
2066
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
2067
}
 
2068
 
 
2069
 
 
2070
inline
 
2071
_bz_VecExpr<_bz_VecExprOp<Range, Range,
 
2072
    _bz_copysign<int,int> > >
 
2073
copysign(Range d1, Range d2)
 
2074
{
 
2075
    typedef _bz_VecExprOp<Range, Range,
 
2076
        _bz_copysign<int,int> > T_expr;
 
2077
 
 
2078
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
2079
}
 
2080
 
 
2081
template<class P_numtype2, int N_length2>
 
2082
inline
 
2083
_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
2084
    _bz_copysign<int,P_numtype2> > >
 
2085
copysign(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
 
2086
{
 
2087
    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
2088
        _bz_copysign<int,P_numtype2> > T_expr;
 
2089
 
 
2090
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
2091
}
 
2092
 
 
2093
 
 
2094
inline
 
2095
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
2096
    _bz_copysign<int,int> > >
 
2097
copysign(Range d1, int d2)
 
2098
{
 
2099
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
2100
        _bz_copysign<int,int> > T_expr;
 
2101
 
 
2102
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
2103
}
 
2104
 
 
2105
 
 
2106
inline
 
2107
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
2108
    _bz_copysign<int,float> > >
 
2109
copysign(Range d1, float d2)
 
2110
{
 
2111
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
2112
        _bz_copysign<int,float> > T_expr;
 
2113
 
 
2114
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
2115
}
 
2116
 
 
2117
 
 
2118
inline
 
2119
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
2120
    _bz_copysign<int,double> > >
 
2121
copysign(Range d1, double d2)
 
2122
{
 
2123
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
2124
        _bz_copysign<int,double> > T_expr;
 
2125
 
 
2126
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
2127
}
 
2128
 
 
2129
 
 
2130
inline
 
2131
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
2132
    _bz_copysign<int,long double> > >
 
2133
copysign(Range d1, long double d2)
 
2134
{
 
2135
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
2136
        _bz_copysign<int,long double> > T_expr;
 
2137
 
 
2138
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
2139
}
 
2140
 
 
2141
template<class T2>
 
2142
inline
 
2143
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
2144
    _bz_copysign<int,complex<T2> > > >
 
2145
copysign(Range d1, complex<T2> d2)
 
2146
{
 
2147
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
2148
        _bz_copysign<int,complex<T2> > > T_expr;
 
2149
 
 
2150
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
2151
}
 
2152
 
 
2153
template<class P_numtype1, int N_length1, class P_numtype2>
 
2154
inline
 
2155
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
2156
    _bz_copysign<P_numtype1,P_numtype2> > >
 
2157
copysign(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
 
2158
{
 
2159
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
2160
        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
 
2161
 
 
2162
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
2163
}
 
2164
 
 
2165
template<class P_numtype1, int N_length1, class P_expr2>
 
2166
inline
 
2167
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
2168
    _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > >
 
2169
copysign(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
 
2170
{
 
2171
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
2172
        _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
2173
 
 
2174
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
2175
}
 
2176
 
 
2177
template<class P_numtype1, int N_length1, class P_numtype2>
 
2178
inline
 
2179
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
2180
    _bz_copysign<P_numtype1,P_numtype2> > >
 
2181
copysign(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
 
2182
{
 
2183
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
2184
        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
 
2185
 
 
2186
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
2187
}
 
2188
 
 
2189
template<class P_numtype1, int N_length1>
 
2190
inline
 
2191
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
2192
    _bz_copysign<P_numtype1,int> > >
 
2193
copysign(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
 
2194
{
 
2195
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
2196
        _bz_copysign<P_numtype1,int> > T_expr;
 
2197
 
 
2198
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
2199
}
 
2200
 
 
2201
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
 
2202
inline
 
2203
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2204
    _bz_copysign<P_numtype1,P_numtype2> > >
 
2205
copysign(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
2206
{
 
2207
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2208
        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
 
2209
 
 
2210
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
2211
}
 
2212
 
 
2213
template<class P_numtype1, int N_length1>
 
2214
inline
 
2215
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
2216
    _bz_copysign<P_numtype1,int> > >
 
2217
copysign(const TinyVector<P_numtype1, N_length1>& d1, int d2)
 
2218
{
 
2219
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
2220
        _bz_copysign<P_numtype1,int> > T_expr;
 
2221
 
 
2222
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
2223
}
 
2224
 
 
2225
template<class P_numtype1, int N_length1>
 
2226
inline
 
2227
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
2228
    _bz_copysign<P_numtype1,float> > >
 
2229
copysign(const TinyVector<P_numtype1, N_length1>& d1, float d2)
 
2230
{
 
2231
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
2232
        _bz_copysign<P_numtype1,float> > T_expr;
 
2233
 
 
2234
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
2235
}
 
2236
 
 
2237
template<class P_numtype1, int N_length1>
 
2238
inline
 
2239
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
2240
    _bz_copysign<P_numtype1,double> > >
 
2241
copysign(const TinyVector<P_numtype1, N_length1>& d1, double d2)
 
2242
{
 
2243
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
2244
        _bz_copysign<P_numtype1,double> > T_expr;
 
2245
 
 
2246
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
2247
}
 
2248
 
 
2249
template<class P_numtype1, int N_length1>
 
2250
inline
 
2251
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
2252
    _bz_copysign<P_numtype1,long double> > >
 
2253
copysign(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
 
2254
{
 
2255
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
2256
        _bz_copysign<P_numtype1,long double> > T_expr;
 
2257
 
 
2258
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
2259
}
 
2260
 
 
2261
template<class P_numtype1, int N_length1, class T2>
 
2262
inline
 
2263
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
2264
    _bz_copysign<P_numtype1,complex<T2> > > >
 
2265
copysign(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
 
2266
{
 
2267
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
2268
        _bz_copysign<P_numtype1,complex<T2> > > T_expr;
 
2269
 
 
2270
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
2271
}
 
2272
 
 
2273
template<class P_numtype2>
 
2274
inline
 
2275
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
2276
    _bz_copysign<int,P_numtype2> > >
 
2277
copysign(int d1, const Vector<P_numtype2>& d2)
 
2278
{
 
2279
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
2280
        _bz_copysign<int,P_numtype2> > T_expr;
 
2281
 
 
2282
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
2283
}
 
2284
 
 
2285
template<class P_expr2>
 
2286
inline
 
2287
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
2288
    _bz_copysign<int,typename P_expr2::T_numtype> > >
 
2289
copysign(int d1, _bz_VecExpr<P_expr2> d2)
 
2290
{
 
2291
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
2292
        _bz_copysign<int,typename P_expr2::T_numtype> > T_expr;
 
2293
 
 
2294
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
2295
}
 
2296
 
 
2297
template<class P_numtype2>
 
2298
inline
 
2299
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
2300
    _bz_copysign<int,P_numtype2> > >
 
2301
copysign(int d1, const VectorPick<P_numtype2>& d2)
 
2302
{
 
2303
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
2304
        _bz_copysign<int,P_numtype2> > T_expr;
 
2305
 
 
2306
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
2307
}
 
2308
 
 
2309
 
 
2310
inline
 
2311
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
2312
    _bz_copysign<int,int> > >
 
2313
copysign(int d1, Range d2)
 
2314
{
 
2315
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
2316
        _bz_copysign<int,int> > T_expr;
 
2317
 
 
2318
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
2319
}
 
2320
 
 
2321
template<class P_numtype2, int N_length2>
 
2322
inline
 
2323
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2324
    _bz_copysign<int,P_numtype2> > >
 
2325
copysign(int d1, const TinyVector<P_numtype2, N_length2>& d2)
 
2326
{
 
2327
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2328
        _bz_copysign<int,P_numtype2> > T_expr;
 
2329
 
 
2330
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
2331
}
 
2332
 
 
2333
template<class P_numtype2>
 
2334
inline
 
2335
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
2336
    _bz_copysign<float,P_numtype2> > >
 
2337
copysign(float d1, const Vector<P_numtype2>& d2)
 
2338
{
 
2339
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
2340
        _bz_copysign<float,P_numtype2> > T_expr;
 
2341
 
 
2342
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
2343
}
 
2344
 
 
2345
template<class P_expr2>
 
2346
inline
 
2347
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
2348
    _bz_copysign<float,typename P_expr2::T_numtype> > >
 
2349
copysign(float d1, _bz_VecExpr<P_expr2> d2)
 
2350
{
 
2351
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
2352
        _bz_copysign<float,typename P_expr2::T_numtype> > T_expr;
 
2353
 
 
2354
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
2355
}
 
2356
 
 
2357
template<class P_numtype2>
 
2358
inline
 
2359
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
2360
    _bz_copysign<float,P_numtype2> > >
 
2361
copysign(float d1, const VectorPick<P_numtype2>& d2)
 
2362
{
 
2363
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
2364
        _bz_copysign<float,P_numtype2> > T_expr;
 
2365
 
 
2366
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
2367
}
 
2368
 
 
2369
 
 
2370
inline
 
2371
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
2372
    _bz_copysign<float,int> > >
 
2373
copysign(float d1, Range d2)
 
2374
{
 
2375
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
2376
        _bz_copysign<float,int> > T_expr;
 
2377
 
 
2378
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
2379
}
 
2380
 
 
2381
template<class P_numtype2, int N_length2>
 
2382
inline
 
2383
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2384
    _bz_copysign<float,P_numtype2> > >
 
2385
copysign(float d1, const TinyVector<P_numtype2, N_length2>& d2)
 
2386
{
 
2387
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2388
        _bz_copysign<float,P_numtype2> > T_expr;
 
2389
 
 
2390
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
2391
}
 
2392
 
 
2393
template<class P_numtype2>
 
2394
inline
 
2395
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
2396
    _bz_copysign<double,P_numtype2> > >
 
2397
copysign(double d1, const Vector<P_numtype2>& d2)
 
2398
{
 
2399
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
2400
        _bz_copysign<double,P_numtype2> > T_expr;
 
2401
 
 
2402
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
2403
}
 
2404
 
 
2405
template<class P_expr2>
 
2406
inline
 
2407
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
2408
    _bz_copysign<double,typename P_expr2::T_numtype> > >
 
2409
copysign(double d1, _bz_VecExpr<P_expr2> d2)
 
2410
{
 
2411
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
2412
        _bz_copysign<double,typename P_expr2::T_numtype> > T_expr;
 
2413
 
 
2414
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
2415
}
 
2416
 
 
2417
template<class P_numtype2>
 
2418
inline
 
2419
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
2420
    _bz_copysign<double,P_numtype2> > >
 
2421
copysign(double d1, const VectorPick<P_numtype2>& d2)
 
2422
{
 
2423
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
2424
        _bz_copysign<double,P_numtype2> > T_expr;
 
2425
 
 
2426
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
2427
}
 
2428
 
 
2429
 
 
2430
inline
 
2431
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
2432
    _bz_copysign<double,int> > >
 
2433
copysign(double d1, Range d2)
 
2434
{
 
2435
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
2436
        _bz_copysign<double,int> > T_expr;
 
2437
 
 
2438
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
2439
}
 
2440
 
 
2441
template<class P_numtype2, int N_length2>
 
2442
inline
 
2443
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2444
    _bz_copysign<double,P_numtype2> > >
 
2445
copysign(double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
2446
{
 
2447
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2448
        _bz_copysign<double,P_numtype2> > T_expr;
 
2449
 
 
2450
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
2451
}
 
2452
 
 
2453
template<class P_numtype2>
 
2454
inline
 
2455
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
2456
    _bz_copysign<long double,P_numtype2> > >
 
2457
copysign(long double d1, const Vector<P_numtype2>& d2)
 
2458
{
 
2459
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
2460
        _bz_copysign<long double,P_numtype2> > T_expr;
 
2461
 
 
2462
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
2463
}
 
2464
 
 
2465
template<class P_expr2>
 
2466
inline
 
2467
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
2468
    _bz_copysign<long double,typename P_expr2::T_numtype> > >
 
2469
copysign(long double d1, _bz_VecExpr<P_expr2> d2)
 
2470
{
 
2471
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
2472
        _bz_copysign<long double,typename P_expr2::T_numtype> > T_expr;
 
2473
 
 
2474
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
2475
}
 
2476
 
 
2477
template<class P_numtype2>
 
2478
inline
 
2479
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
2480
    _bz_copysign<long double,P_numtype2> > >
 
2481
copysign(long double d1, const VectorPick<P_numtype2>& d2)
 
2482
{
 
2483
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
2484
        _bz_copysign<long double,P_numtype2> > T_expr;
 
2485
 
 
2486
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
2487
}
 
2488
 
 
2489
 
 
2490
inline
 
2491
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
2492
    _bz_copysign<long double,int> > >
 
2493
copysign(long double d1, Range d2)
 
2494
{
 
2495
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
2496
        _bz_copysign<long double,int> > T_expr;
 
2497
 
 
2498
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
2499
}
 
2500
 
 
2501
template<class P_numtype2, int N_length2>
 
2502
inline
 
2503
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2504
    _bz_copysign<long double,P_numtype2> > >
 
2505
copysign(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
2506
{
 
2507
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2508
        _bz_copysign<long double,P_numtype2> > T_expr;
 
2509
 
 
2510
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
2511
}
 
2512
 
 
2513
template<class T1, class P_numtype2>
 
2514
inline
 
2515
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
2516
    _bz_copysign<complex<T1> ,P_numtype2> > >
 
2517
copysign(complex<T1> d1, const Vector<P_numtype2>& d2)
 
2518
{
 
2519
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
2520
        _bz_copysign<complex<T1> ,P_numtype2> > T_expr;
 
2521
 
 
2522
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
2523
}
 
2524
 
 
2525
template<class T1, class P_expr2>
 
2526
inline
 
2527
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
2528
    _bz_copysign<complex<T1> ,typename P_expr2::T_numtype> > >
 
2529
copysign(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
 
2530
{
 
2531
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
2532
        _bz_copysign<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
 
2533
 
 
2534
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
2535
}
 
2536
 
 
2537
template<class T1, class P_numtype2>
 
2538
inline
 
2539
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
2540
    _bz_copysign<complex<T1> ,P_numtype2> > >
 
2541
copysign(complex<T1> d1, const VectorPick<P_numtype2>& d2)
 
2542
{
 
2543
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
2544
        _bz_copysign<complex<T1> ,P_numtype2> > T_expr;
 
2545
 
 
2546
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
2547
}
 
2548
 
 
2549
template<class T1>
 
2550
inline
 
2551
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
2552
    _bz_copysign<complex<T1> ,int> > >
 
2553
copysign(complex<T1> d1, Range d2)
 
2554
{
 
2555
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
2556
        _bz_copysign<complex<T1> ,int> > T_expr;
 
2557
 
 
2558
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
2559
}
 
2560
 
 
2561
template<class T1, class P_numtype2, int N_length2>
 
2562
inline
 
2563
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
2564
    _bz_copysign<complex<T1> ,P_numtype2> > >
 
2565
copysign(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
2566
{
 
2567
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
2568
        _bz_copysign<complex<T1> ,P_numtype2> > T_expr;
 
2569
 
 
2570
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
2571
}
 
2572
 
 
2573
#endif
 
2574
 
 
2575
/****************************************************************************
 
2576
 * cos
 
2577
 ****************************************************************************/
 
2578
 
 
2579
template<class P_numtype1>
 
2580
inline
 
2581
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
2582
    _bz_cos<P_numtype1> > >
 
2583
cos(const Vector<P_numtype1>& d1)
 
2584
{
 
2585
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
2586
        _bz_cos<P_numtype1> > T_expr;
 
2587
 
 
2588
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
2589
}
 
2590
 
 
2591
template<class P_expr1>
 
2592
inline
 
2593
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
2594
    _bz_cos<typename P_expr1::T_numtype> > >
 
2595
cos(_bz_VecExpr<P_expr1> d1)
 
2596
{
 
2597
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
2598
        _bz_cos<typename P_expr1::T_numtype> > T_expr;
 
2599
 
 
2600
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
2601
}
 
2602
 
 
2603
template<class P_numtype1>
 
2604
inline
 
2605
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
2606
    _bz_cos<P_numtype1> > >
 
2607
cos(const VectorPick<P_numtype1>& d1)
 
2608
{
 
2609
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
2610
        _bz_cos<P_numtype1> > T_expr;
 
2611
 
 
2612
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
2613
}
 
2614
 
 
2615
 
 
2616
inline
 
2617
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
2618
    _bz_cos<int> > >
 
2619
cos(Range d1)
 
2620
{
 
2621
    typedef _bz_VecExprUnaryOp<Range,
 
2622
        _bz_cos<int> > T_expr;
 
2623
 
 
2624
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
2625
}
 
2626
 
 
2627
template<class P_numtype1, int N_length1>
 
2628
inline
 
2629
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
2630
    _bz_cos<P_numtype1> > >
 
2631
cos(const TinyVector<P_numtype1, N_length1>& d1)
 
2632
{
 
2633
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
2634
        _bz_cos<P_numtype1> > T_expr;
 
2635
 
 
2636
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
2637
}
 
2638
 
 
2639
 
 
2640
/****************************************************************************
 
2641
 * cosh
 
2642
 ****************************************************************************/
 
2643
 
 
2644
template<class P_numtype1>
 
2645
inline
 
2646
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
2647
    _bz_cosh<P_numtype1> > >
 
2648
cosh(const Vector<P_numtype1>& d1)
 
2649
{
 
2650
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
2651
        _bz_cosh<P_numtype1> > T_expr;
 
2652
 
 
2653
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
2654
}
 
2655
 
 
2656
template<class P_expr1>
 
2657
inline
 
2658
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
2659
    _bz_cosh<typename P_expr1::T_numtype> > >
 
2660
cosh(_bz_VecExpr<P_expr1> d1)
 
2661
{
 
2662
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
2663
        _bz_cosh<typename P_expr1::T_numtype> > T_expr;
 
2664
 
 
2665
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
2666
}
 
2667
 
 
2668
template<class P_numtype1>
 
2669
inline
 
2670
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
2671
    _bz_cosh<P_numtype1> > >
 
2672
cosh(const VectorPick<P_numtype1>& d1)
 
2673
{
 
2674
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
2675
        _bz_cosh<P_numtype1> > T_expr;
 
2676
 
 
2677
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
2678
}
 
2679
 
 
2680
 
 
2681
inline
 
2682
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
2683
    _bz_cosh<int> > >
 
2684
cosh(Range d1)
 
2685
{
 
2686
    typedef _bz_VecExprUnaryOp<Range,
 
2687
        _bz_cosh<int> > T_expr;
 
2688
 
 
2689
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
2690
}
 
2691
 
 
2692
template<class P_numtype1, int N_length1>
 
2693
inline
 
2694
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
2695
    _bz_cosh<P_numtype1> > >
 
2696
cosh(const TinyVector<P_numtype1, N_length1>& d1)
 
2697
{
 
2698
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
2699
        _bz_cosh<P_numtype1> > T_expr;
 
2700
 
 
2701
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
2702
}
 
2703
 
 
2704
 
 
2705
/****************************************************************************
 
2706
 * drem
 
2707
 ****************************************************************************/
 
2708
 
 
2709
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
2710
template<class P_numtype1, class P_numtype2>
 
2711
inline
 
2712
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
2713
    _bz_drem<P_numtype1,P_numtype2> > >
 
2714
drem(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
2715
{
 
2716
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
2717
        _bz_drem<P_numtype1,P_numtype2> > T_expr;
 
2718
 
 
2719
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
2720
}
 
2721
 
 
2722
template<class P_numtype1, class P_expr2>
 
2723
inline
 
2724
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
2725
    _bz_drem<P_numtype1,typename P_expr2::T_numtype> > >
 
2726
drem(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
2727
{
 
2728
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
2729
        _bz_drem<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
2730
 
 
2731
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
2732
}
 
2733
 
 
2734
template<class P_numtype1, class P_numtype2>
 
2735
inline
 
2736
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
2737
    _bz_drem<P_numtype1,P_numtype2> > >
 
2738
drem(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
2739
{
 
2740
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
2741
        _bz_drem<P_numtype1,P_numtype2> > T_expr;
 
2742
 
 
2743
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
2744
}
 
2745
 
 
2746
template<class P_numtype1>
 
2747
inline
 
2748
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
2749
    _bz_drem<P_numtype1,int> > >
 
2750
drem(const Vector<P_numtype1>& d1, Range d2)
 
2751
{
 
2752
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
2753
        _bz_drem<P_numtype1,int> > T_expr;
 
2754
 
 
2755
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
2756
}
 
2757
 
 
2758
template<class P_numtype1, class P_numtype2, int N_length2>
 
2759
inline
 
2760
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2761
    _bz_drem<P_numtype1,P_numtype2> > >
 
2762
drem(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
2763
{
 
2764
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2765
        _bz_drem<P_numtype1,P_numtype2> > T_expr;
 
2766
 
 
2767
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
2768
}
 
2769
 
 
2770
template<class P_numtype1>
 
2771
inline
 
2772
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
2773
    _bz_drem<P_numtype1,int> > >
 
2774
drem(const Vector<P_numtype1>& d1, int d2)
 
2775
{
 
2776
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
2777
        _bz_drem<P_numtype1,int> > T_expr;
 
2778
 
 
2779
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
2780
}
 
2781
 
 
2782
template<class P_numtype1>
 
2783
inline
 
2784
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
2785
    _bz_drem<P_numtype1,float> > >
 
2786
drem(const Vector<P_numtype1>& d1, float d2)
 
2787
{
 
2788
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
2789
        _bz_drem<P_numtype1,float> > T_expr;
 
2790
 
 
2791
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
2792
}
 
2793
 
 
2794
template<class P_numtype1>
 
2795
inline
 
2796
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
2797
    _bz_drem<P_numtype1,double> > >
 
2798
drem(const Vector<P_numtype1>& d1, double d2)
 
2799
{
 
2800
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
2801
        _bz_drem<P_numtype1,double> > T_expr;
 
2802
 
 
2803
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
2804
}
 
2805
 
 
2806
template<class P_numtype1>
 
2807
inline
 
2808
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
2809
    _bz_drem<P_numtype1,long double> > >
 
2810
drem(const Vector<P_numtype1>& d1, long double d2)
 
2811
{
 
2812
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
2813
        _bz_drem<P_numtype1,long double> > T_expr;
 
2814
 
 
2815
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
2816
}
 
2817
 
 
2818
template<class P_numtype1, class T2>
 
2819
inline
 
2820
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
2821
    _bz_drem<P_numtype1,complex<T2> > > >
 
2822
drem(const Vector<P_numtype1>& d1, complex<T2> d2)
 
2823
{
 
2824
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
2825
        _bz_drem<P_numtype1,complex<T2> > > T_expr;
 
2826
 
 
2827
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
2828
}
 
2829
 
 
2830
template<class P_expr1, class P_numtype2>
 
2831
inline
 
2832
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
2833
    _bz_drem<typename P_expr1::T_numtype,P_numtype2> > >
 
2834
drem(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
 
2835
{
 
2836
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
2837
        _bz_drem<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
2838
 
 
2839
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
2840
}
 
2841
 
 
2842
template<class P_expr1, class P_expr2>
 
2843
inline
 
2844
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
2845
    _bz_drem<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
 
2846
drem(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
 
2847
{
 
2848
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
2849
        _bz_drem<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
 
2850
 
 
2851
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
2852
}
 
2853
 
 
2854
template<class P_expr1, class P_numtype2>
 
2855
inline
 
2856
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
2857
    _bz_drem<typename P_expr1::T_numtype,P_numtype2> > >
 
2858
drem(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
 
2859
{
 
2860
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
2861
        _bz_drem<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
2862
 
 
2863
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
2864
}
 
2865
 
 
2866
template<class P_expr1>
 
2867
inline
 
2868
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
2869
    _bz_drem<typename P_expr1::T_numtype,int> > >
 
2870
drem(_bz_VecExpr<P_expr1> d1, Range d2)
 
2871
{
 
2872
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
2873
        _bz_drem<typename P_expr1::T_numtype,int> > T_expr;
 
2874
 
 
2875
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
2876
}
 
2877
 
 
2878
template<class P_expr1, class P_numtype2, int N_length2>
 
2879
inline
 
2880
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2881
    _bz_drem<typename P_expr1::T_numtype,P_numtype2> > >
 
2882
drem(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
2883
{
 
2884
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
2885
        _bz_drem<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
2886
 
 
2887
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
2888
}
 
2889
 
 
2890
template<class P_expr1>
 
2891
inline
 
2892
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
2893
    _bz_drem<typename P_expr1::T_numtype,int> > >
 
2894
drem(_bz_VecExpr<P_expr1> d1, int d2)
 
2895
{
 
2896
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
2897
        _bz_drem<typename P_expr1::T_numtype,int> > T_expr;
 
2898
 
 
2899
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
2900
}
 
2901
 
 
2902
template<class P_expr1>
 
2903
inline
 
2904
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
2905
    _bz_drem<typename P_expr1::T_numtype,float> > >
 
2906
drem(_bz_VecExpr<P_expr1> d1, float d2)
 
2907
{
 
2908
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
2909
        _bz_drem<typename P_expr1::T_numtype,float> > T_expr;
 
2910
 
 
2911
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
2912
}
 
2913
 
 
2914
template<class P_expr1>
 
2915
inline
 
2916
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
2917
    _bz_drem<typename P_expr1::T_numtype,double> > >
 
2918
drem(_bz_VecExpr<P_expr1> d1, double d2)
 
2919
{
 
2920
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
2921
        _bz_drem<typename P_expr1::T_numtype,double> > T_expr;
 
2922
 
 
2923
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
2924
}
 
2925
 
 
2926
template<class P_expr1>
 
2927
inline
 
2928
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
2929
    _bz_drem<typename P_expr1::T_numtype,long double> > >
 
2930
drem(_bz_VecExpr<P_expr1> d1, long double d2)
 
2931
{
 
2932
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
2933
        _bz_drem<typename P_expr1::T_numtype,long double> > T_expr;
 
2934
 
 
2935
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
2936
}
 
2937
 
 
2938
template<class P_expr1, class T2>
 
2939
inline
 
2940
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
2941
    _bz_drem<typename P_expr1::T_numtype,complex<T2> > > >
 
2942
drem(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
 
2943
{
 
2944
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
2945
        _bz_drem<typename P_expr1::T_numtype,complex<T2> > > T_expr;
 
2946
 
 
2947
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
2948
}
 
2949
 
 
2950
template<class P_numtype1, class P_numtype2>
 
2951
inline
 
2952
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
2953
    _bz_drem<P_numtype1,P_numtype2> > >
 
2954
drem(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
2955
{
 
2956
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
2957
        _bz_drem<P_numtype1,P_numtype2> > T_expr;
 
2958
 
 
2959
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
2960
}
 
2961
 
 
2962
template<class P_numtype1, class P_expr2>
 
2963
inline
 
2964
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
2965
    _bz_drem<P_numtype1,typename P_expr2::T_numtype> > >
 
2966
drem(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
2967
{
 
2968
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
2969
        _bz_drem<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
2970
 
 
2971
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
2972
}
 
2973
 
 
2974
template<class P_numtype1, class P_numtype2>
 
2975
inline
 
2976
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
2977
    _bz_drem<P_numtype1,P_numtype2> > >
 
2978
drem(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
2979
{
 
2980
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
2981
        _bz_drem<P_numtype1,P_numtype2> > T_expr;
 
2982
 
 
2983
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
2984
}
 
2985
 
 
2986
template<class P_numtype1>
 
2987
inline
 
2988
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
2989
    _bz_drem<P_numtype1,int> > >
 
2990
drem(const VectorPick<P_numtype1>& d1, Range d2)
 
2991
{
 
2992
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
2993
        _bz_drem<P_numtype1,int> > T_expr;
 
2994
 
 
2995
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
2996
}
 
2997
 
 
2998
template<class P_numtype1, class P_numtype2, int N_length2>
 
2999
inline
 
3000
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3001
    _bz_drem<P_numtype1,P_numtype2> > >
 
3002
drem(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
3003
{
 
3004
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3005
        _bz_drem<P_numtype1,P_numtype2> > T_expr;
 
3006
 
 
3007
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
3008
}
 
3009
 
 
3010
template<class P_numtype1>
 
3011
inline
 
3012
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
3013
    _bz_drem<P_numtype1,int> > >
 
3014
drem(const VectorPick<P_numtype1>& d1, int d2)
 
3015
{
 
3016
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
3017
        _bz_drem<P_numtype1,int> > T_expr;
 
3018
 
 
3019
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
3020
}
 
3021
 
 
3022
template<class P_numtype1>
 
3023
inline
 
3024
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
3025
    _bz_drem<P_numtype1,float> > >
 
3026
drem(const VectorPick<P_numtype1>& d1, float d2)
 
3027
{
 
3028
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
3029
        _bz_drem<P_numtype1,float> > T_expr;
 
3030
 
 
3031
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
3032
}
 
3033
 
 
3034
template<class P_numtype1>
 
3035
inline
 
3036
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
3037
    _bz_drem<P_numtype1,double> > >
 
3038
drem(const VectorPick<P_numtype1>& d1, double d2)
 
3039
{
 
3040
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
3041
        _bz_drem<P_numtype1,double> > T_expr;
 
3042
 
 
3043
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
3044
}
 
3045
 
 
3046
template<class P_numtype1>
 
3047
inline
 
3048
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
3049
    _bz_drem<P_numtype1,long double> > >
 
3050
drem(const VectorPick<P_numtype1>& d1, long double d2)
 
3051
{
 
3052
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
3053
        _bz_drem<P_numtype1,long double> > T_expr;
 
3054
 
 
3055
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
3056
}
 
3057
 
 
3058
template<class P_numtype1, class T2>
 
3059
inline
 
3060
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
3061
    _bz_drem<P_numtype1,complex<T2> > > >
 
3062
drem(const VectorPick<P_numtype1>& d1, complex<T2> d2)
 
3063
{
 
3064
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
3065
        _bz_drem<P_numtype1,complex<T2> > > T_expr;
 
3066
 
 
3067
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
3068
}
 
3069
 
 
3070
template<class P_numtype2>
 
3071
inline
 
3072
_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
3073
    _bz_drem<int,P_numtype2> > >
 
3074
drem(Range d1, const Vector<P_numtype2>& d2)
 
3075
{
 
3076
    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
3077
        _bz_drem<int,P_numtype2> > T_expr;
 
3078
 
 
3079
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
3080
}
 
3081
 
 
3082
template<class P_expr2>
 
3083
inline
 
3084
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
3085
    _bz_drem<int,typename P_expr2::T_numtype> > >
 
3086
drem(Range d1, _bz_VecExpr<P_expr2> d2)
 
3087
{
 
3088
    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
3089
        _bz_drem<int,typename P_expr2::T_numtype> > T_expr;
 
3090
 
 
3091
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
3092
}
 
3093
 
 
3094
template<class P_numtype2>
 
3095
inline
 
3096
_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
3097
    _bz_drem<int,P_numtype2> > >
 
3098
drem(Range d1, const VectorPick<P_numtype2>& d2)
 
3099
{
 
3100
    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
3101
        _bz_drem<int,P_numtype2> > T_expr;
 
3102
 
 
3103
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
3104
}
 
3105
 
 
3106
 
 
3107
inline
 
3108
_bz_VecExpr<_bz_VecExprOp<Range, Range,
 
3109
    _bz_drem<int,int> > >
 
3110
drem(Range d1, Range d2)
 
3111
{
 
3112
    typedef _bz_VecExprOp<Range, Range,
 
3113
        _bz_drem<int,int> > T_expr;
 
3114
 
 
3115
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
3116
}
 
3117
 
 
3118
template<class P_numtype2, int N_length2>
 
3119
inline
 
3120
_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
3121
    _bz_drem<int,P_numtype2> > >
 
3122
drem(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
 
3123
{
 
3124
    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
3125
        _bz_drem<int,P_numtype2> > T_expr;
 
3126
 
 
3127
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
3128
}
 
3129
 
 
3130
 
 
3131
inline
 
3132
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
3133
    _bz_drem<int,int> > >
 
3134
drem(Range d1, int d2)
 
3135
{
 
3136
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
3137
        _bz_drem<int,int> > T_expr;
 
3138
 
 
3139
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
3140
}
 
3141
 
 
3142
 
 
3143
inline
 
3144
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
3145
    _bz_drem<int,float> > >
 
3146
drem(Range d1, float d2)
 
3147
{
 
3148
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
3149
        _bz_drem<int,float> > T_expr;
 
3150
 
 
3151
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
3152
}
 
3153
 
 
3154
 
 
3155
inline
 
3156
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
3157
    _bz_drem<int,double> > >
 
3158
drem(Range d1, double d2)
 
3159
{
 
3160
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
3161
        _bz_drem<int,double> > T_expr;
 
3162
 
 
3163
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
3164
}
 
3165
 
 
3166
 
 
3167
inline
 
3168
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
3169
    _bz_drem<int,long double> > >
 
3170
drem(Range d1, long double d2)
 
3171
{
 
3172
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
3173
        _bz_drem<int,long double> > T_expr;
 
3174
 
 
3175
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
3176
}
 
3177
 
 
3178
template<class T2>
 
3179
inline
 
3180
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
3181
    _bz_drem<int,complex<T2> > > >
 
3182
drem(Range d1, complex<T2> d2)
 
3183
{
 
3184
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
3185
        _bz_drem<int,complex<T2> > > T_expr;
 
3186
 
 
3187
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
3188
}
 
3189
 
 
3190
template<class P_numtype1, int N_length1, class P_numtype2>
 
3191
inline
 
3192
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
3193
    _bz_drem<P_numtype1,P_numtype2> > >
 
3194
drem(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
 
3195
{
 
3196
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
3197
        _bz_drem<P_numtype1,P_numtype2> > T_expr;
 
3198
 
 
3199
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
3200
}
 
3201
 
 
3202
template<class P_numtype1, int N_length1, class P_expr2>
 
3203
inline
 
3204
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
3205
    _bz_drem<P_numtype1,typename P_expr2::T_numtype> > >
 
3206
drem(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
 
3207
{
 
3208
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
3209
        _bz_drem<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
3210
 
 
3211
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
3212
}
 
3213
 
 
3214
template<class P_numtype1, int N_length1, class P_numtype2>
 
3215
inline
 
3216
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
3217
    _bz_drem<P_numtype1,P_numtype2> > >
 
3218
drem(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
 
3219
{
 
3220
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
3221
        _bz_drem<P_numtype1,P_numtype2> > T_expr;
 
3222
 
 
3223
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
3224
}
 
3225
 
 
3226
template<class P_numtype1, int N_length1>
 
3227
inline
 
3228
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
3229
    _bz_drem<P_numtype1,int> > >
 
3230
drem(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
 
3231
{
 
3232
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
3233
        _bz_drem<P_numtype1,int> > T_expr;
 
3234
 
 
3235
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
3236
}
 
3237
 
 
3238
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
 
3239
inline
 
3240
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3241
    _bz_drem<P_numtype1,P_numtype2> > >
 
3242
drem(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
3243
{
 
3244
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3245
        _bz_drem<P_numtype1,P_numtype2> > T_expr;
 
3246
 
 
3247
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
3248
}
 
3249
 
 
3250
template<class P_numtype1, int N_length1>
 
3251
inline
 
3252
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
3253
    _bz_drem<P_numtype1,int> > >
 
3254
drem(const TinyVector<P_numtype1, N_length1>& d1, int d2)
 
3255
{
 
3256
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
3257
        _bz_drem<P_numtype1,int> > T_expr;
 
3258
 
 
3259
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
3260
}
 
3261
 
 
3262
template<class P_numtype1, int N_length1>
 
3263
inline
 
3264
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
3265
    _bz_drem<P_numtype1,float> > >
 
3266
drem(const TinyVector<P_numtype1, N_length1>& d1, float d2)
 
3267
{
 
3268
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
3269
        _bz_drem<P_numtype1,float> > T_expr;
 
3270
 
 
3271
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
3272
}
 
3273
 
 
3274
template<class P_numtype1, int N_length1>
 
3275
inline
 
3276
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
3277
    _bz_drem<P_numtype1,double> > >
 
3278
drem(const TinyVector<P_numtype1, N_length1>& d1, double d2)
 
3279
{
 
3280
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
3281
        _bz_drem<P_numtype1,double> > T_expr;
 
3282
 
 
3283
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
3284
}
 
3285
 
 
3286
template<class P_numtype1, int N_length1>
 
3287
inline
 
3288
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
3289
    _bz_drem<P_numtype1,long double> > >
 
3290
drem(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
 
3291
{
 
3292
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
3293
        _bz_drem<P_numtype1,long double> > T_expr;
 
3294
 
 
3295
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
3296
}
 
3297
 
 
3298
template<class P_numtype1, int N_length1, class T2>
 
3299
inline
 
3300
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
3301
    _bz_drem<P_numtype1,complex<T2> > > >
 
3302
drem(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
 
3303
{
 
3304
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
3305
        _bz_drem<P_numtype1,complex<T2> > > T_expr;
 
3306
 
 
3307
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
3308
}
 
3309
 
 
3310
template<class P_numtype2>
 
3311
inline
 
3312
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
3313
    _bz_drem<int,P_numtype2> > >
 
3314
drem(int d1, const Vector<P_numtype2>& d2)
 
3315
{
 
3316
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
3317
        _bz_drem<int,P_numtype2> > T_expr;
 
3318
 
 
3319
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
3320
}
 
3321
 
 
3322
template<class P_expr2>
 
3323
inline
 
3324
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
3325
    _bz_drem<int,typename P_expr2::T_numtype> > >
 
3326
drem(int d1, _bz_VecExpr<P_expr2> d2)
 
3327
{
 
3328
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
3329
        _bz_drem<int,typename P_expr2::T_numtype> > T_expr;
 
3330
 
 
3331
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
3332
}
 
3333
 
 
3334
template<class P_numtype2>
 
3335
inline
 
3336
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
3337
    _bz_drem<int,P_numtype2> > >
 
3338
drem(int d1, const VectorPick<P_numtype2>& d2)
 
3339
{
 
3340
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
3341
        _bz_drem<int,P_numtype2> > T_expr;
 
3342
 
 
3343
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
3344
}
 
3345
 
 
3346
 
 
3347
inline
 
3348
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
3349
    _bz_drem<int,int> > >
 
3350
drem(int d1, Range d2)
 
3351
{
 
3352
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
3353
        _bz_drem<int,int> > T_expr;
 
3354
 
 
3355
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
3356
}
 
3357
 
 
3358
template<class P_numtype2, int N_length2>
 
3359
inline
 
3360
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3361
    _bz_drem<int,P_numtype2> > >
 
3362
drem(int d1, const TinyVector<P_numtype2, N_length2>& d2)
 
3363
{
 
3364
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3365
        _bz_drem<int,P_numtype2> > T_expr;
 
3366
 
 
3367
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
3368
}
 
3369
 
 
3370
template<class P_numtype2>
 
3371
inline
 
3372
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
3373
    _bz_drem<float,P_numtype2> > >
 
3374
drem(float d1, const Vector<P_numtype2>& d2)
 
3375
{
 
3376
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
3377
        _bz_drem<float,P_numtype2> > T_expr;
 
3378
 
 
3379
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
3380
}
 
3381
 
 
3382
template<class P_expr2>
 
3383
inline
 
3384
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
3385
    _bz_drem<float,typename P_expr2::T_numtype> > >
 
3386
drem(float d1, _bz_VecExpr<P_expr2> d2)
 
3387
{
 
3388
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
3389
        _bz_drem<float,typename P_expr2::T_numtype> > T_expr;
 
3390
 
 
3391
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
3392
}
 
3393
 
 
3394
template<class P_numtype2>
 
3395
inline
 
3396
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
3397
    _bz_drem<float,P_numtype2> > >
 
3398
drem(float d1, const VectorPick<P_numtype2>& d2)
 
3399
{
 
3400
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
3401
        _bz_drem<float,P_numtype2> > T_expr;
 
3402
 
 
3403
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
3404
}
 
3405
 
 
3406
 
 
3407
inline
 
3408
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
3409
    _bz_drem<float,int> > >
 
3410
drem(float d1, Range d2)
 
3411
{
 
3412
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
3413
        _bz_drem<float,int> > T_expr;
 
3414
 
 
3415
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
3416
}
 
3417
 
 
3418
template<class P_numtype2, int N_length2>
 
3419
inline
 
3420
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3421
    _bz_drem<float,P_numtype2> > >
 
3422
drem(float d1, const TinyVector<P_numtype2, N_length2>& d2)
 
3423
{
 
3424
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3425
        _bz_drem<float,P_numtype2> > T_expr;
 
3426
 
 
3427
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
3428
}
 
3429
 
 
3430
template<class P_numtype2>
 
3431
inline
 
3432
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
3433
    _bz_drem<double,P_numtype2> > >
 
3434
drem(double d1, const Vector<P_numtype2>& d2)
 
3435
{
 
3436
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
3437
        _bz_drem<double,P_numtype2> > T_expr;
 
3438
 
 
3439
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
3440
}
 
3441
 
 
3442
template<class P_expr2>
 
3443
inline
 
3444
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
3445
    _bz_drem<double,typename P_expr2::T_numtype> > >
 
3446
drem(double d1, _bz_VecExpr<P_expr2> d2)
 
3447
{
 
3448
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
3449
        _bz_drem<double,typename P_expr2::T_numtype> > T_expr;
 
3450
 
 
3451
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
3452
}
 
3453
 
 
3454
template<class P_numtype2>
 
3455
inline
 
3456
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
3457
    _bz_drem<double,P_numtype2> > >
 
3458
drem(double d1, const VectorPick<P_numtype2>& d2)
 
3459
{
 
3460
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
3461
        _bz_drem<double,P_numtype2> > T_expr;
 
3462
 
 
3463
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
3464
}
 
3465
 
 
3466
 
 
3467
inline
 
3468
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
3469
    _bz_drem<double,int> > >
 
3470
drem(double d1, Range d2)
 
3471
{
 
3472
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
3473
        _bz_drem<double,int> > T_expr;
 
3474
 
 
3475
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
3476
}
 
3477
 
 
3478
template<class P_numtype2, int N_length2>
 
3479
inline
 
3480
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3481
    _bz_drem<double,P_numtype2> > >
 
3482
drem(double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
3483
{
 
3484
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3485
        _bz_drem<double,P_numtype2> > T_expr;
 
3486
 
 
3487
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
3488
}
 
3489
 
 
3490
template<class P_numtype2>
 
3491
inline
 
3492
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
3493
    _bz_drem<long double,P_numtype2> > >
 
3494
drem(long double d1, const Vector<P_numtype2>& d2)
 
3495
{
 
3496
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
3497
        _bz_drem<long double,P_numtype2> > T_expr;
 
3498
 
 
3499
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
3500
}
 
3501
 
 
3502
template<class P_expr2>
 
3503
inline
 
3504
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
3505
    _bz_drem<long double,typename P_expr2::T_numtype> > >
 
3506
drem(long double d1, _bz_VecExpr<P_expr2> d2)
 
3507
{
 
3508
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
3509
        _bz_drem<long double,typename P_expr2::T_numtype> > T_expr;
 
3510
 
 
3511
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
3512
}
 
3513
 
 
3514
template<class P_numtype2>
 
3515
inline
 
3516
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
3517
    _bz_drem<long double,P_numtype2> > >
 
3518
drem(long double d1, const VectorPick<P_numtype2>& d2)
 
3519
{
 
3520
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
3521
        _bz_drem<long double,P_numtype2> > T_expr;
 
3522
 
 
3523
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
3524
}
 
3525
 
 
3526
 
 
3527
inline
 
3528
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
3529
    _bz_drem<long double,int> > >
 
3530
drem(long double d1, Range d2)
 
3531
{
 
3532
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
3533
        _bz_drem<long double,int> > T_expr;
 
3534
 
 
3535
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
3536
}
 
3537
 
 
3538
template<class P_numtype2, int N_length2>
 
3539
inline
 
3540
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3541
    _bz_drem<long double,P_numtype2> > >
 
3542
drem(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
3543
{
 
3544
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
3545
        _bz_drem<long double,P_numtype2> > T_expr;
 
3546
 
 
3547
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
3548
}
 
3549
 
 
3550
template<class T1, class P_numtype2>
 
3551
inline
 
3552
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
3553
    _bz_drem<complex<T1> ,P_numtype2> > >
 
3554
drem(complex<T1> d1, const Vector<P_numtype2>& d2)
 
3555
{
 
3556
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
3557
        _bz_drem<complex<T1> ,P_numtype2> > T_expr;
 
3558
 
 
3559
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
3560
}
 
3561
 
 
3562
template<class T1, class P_expr2>
 
3563
inline
 
3564
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
3565
    _bz_drem<complex<T1> ,typename P_expr2::T_numtype> > >
 
3566
drem(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
 
3567
{
 
3568
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
3569
        _bz_drem<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
 
3570
 
 
3571
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
3572
}
 
3573
 
 
3574
template<class T1, class P_numtype2>
 
3575
inline
 
3576
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
3577
    _bz_drem<complex<T1> ,P_numtype2> > >
 
3578
drem(complex<T1> d1, const VectorPick<P_numtype2>& d2)
 
3579
{
 
3580
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
3581
        _bz_drem<complex<T1> ,P_numtype2> > T_expr;
 
3582
 
 
3583
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
3584
}
 
3585
 
 
3586
template<class T1>
 
3587
inline
 
3588
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
3589
    _bz_drem<complex<T1> ,int> > >
 
3590
drem(complex<T1> d1, Range d2)
 
3591
{
 
3592
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
3593
        _bz_drem<complex<T1> ,int> > T_expr;
 
3594
 
 
3595
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
3596
}
 
3597
 
 
3598
template<class T1, class P_numtype2, int N_length2>
 
3599
inline
 
3600
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
3601
    _bz_drem<complex<T1> ,P_numtype2> > >
 
3602
drem(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
3603
{
 
3604
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
3605
        _bz_drem<complex<T1> ,P_numtype2> > T_expr;
 
3606
 
 
3607
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
3608
}
 
3609
 
 
3610
#endif
 
3611
 
 
3612
/****************************************************************************
 
3613
 * exp
 
3614
 ****************************************************************************/
 
3615
 
 
3616
template<class P_numtype1>
 
3617
inline
 
3618
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3619
    _bz_exp<P_numtype1> > >
 
3620
exp(const Vector<P_numtype1>& d1)
 
3621
{
 
3622
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3623
        _bz_exp<P_numtype1> > T_expr;
 
3624
 
 
3625
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3626
}
 
3627
 
 
3628
template<class P_expr1>
 
3629
inline
 
3630
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3631
    _bz_exp<typename P_expr1::T_numtype> > >
 
3632
exp(_bz_VecExpr<P_expr1> d1)
 
3633
{
 
3634
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3635
        _bz_exp<typename P_expr1::T_numtype> > T_expr;
 
3636
 
 
3637
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3638
}
 
3639
 
 
3640
template<class P_numtype1>
 
3641
inline
 
3642
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3643
    _bz_exp<P_numtype1> > >
 
3644
exp(const VectorPick<P_numtype1>& d1)
 
3645
{
 
3646
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3647
        _bz_exp<P_numtype1> > T_expr;
 
3648
 
 
3649
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3650
}
 
3651
 
 
3652
 
 
3653
inline
 
3654
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
3655
    _bz_exp<int> > >
 
3656
exp(Range d1)
 
3657
{
 
3658
    typedef _bz_VecExprUnaryOp<Range,
 
3659
        _bz_exp<int> > T_expr;
 
3660
 
 
3661
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3662
}
 
3663
 
 
3664
template<class P_numtype1, int N_length1>
 
3665
inline
 
3666
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3667
    _bz_exp<P_numtype1> > >
 
3668
exp(const TinyVector<P_numtype1, N_length1>& d1)
 
3669
{
 
3670
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3671
        _bz_exp<P_numtype1> > T_expr;
 
3672
 
 
3673
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3674
}
 
3675
 
 
3676
 
 
3677
/****************************************************************************
 
3678
 * expm1
 
3679
 ****************************************************************************/
 
3680
 
 
3681
#ifdef BZ_HAVE_IEEE_MATH
 
3682
template<class P_numtype1>
 
3683
inline
 
3684
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3685
    _bz_expm1<P_numtype1> > >
 
3686
expm1(const Vector<P_numtype1>& d1)
 
3687
{
 
3688
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3689
        _bz_expm1<P_numtype1> > T_expr;
 
3690
 
 
3691
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3692
}
 
3693
 
 
3694
template<class P_expr1>
 
3695
inline
 
3696
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3697
    _bz_expm1<typename P_expr1::T_numtype> > >
 
3698
expm1(_bz_VecExpr<P_expr1> d1)
 
3699
{
 
3700
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3701
        _bz_expm1<typename P_expr1::T_numtype> > T_expr;
 
3702
 
 
3703
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3704
}
 
3705
 
 
3706
template<class P_numtype1>
 
3707
inline
 
3708
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3709
    _bz_expm1<P_numtype1> > >
 
3710
expm1(const VectorPick<P_numtype1>& d1)
 
3711
{
 
3712
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3713
        _bz_expm1<P_numtype1> > T_expr;
 
3714
 
 
3715
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3716
}
 
3717
 
 
3718
 
 
3719
inline
 
3720
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
3721
    _bz_expm1<int> > >
 
3722
expm1(Range d1)
 
3723
{
 
3724
    typedef _bz_VecExprUnaryOp<Range,
 
3725
        _bz_expm1<int> > T_expr;
 
3726
 
 
3727
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3728
}
 
3729
 
 
3730
template<class P_numtype1, int N_length1>
 
3731
inline
 
3732
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3733
    _bz_expm1<P_numtype1> > >
 
3734
expm1(const TinyVector<P_numtype1, N_length1>& d1)
 
3735
{
 
3736
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3737
        _bz_expm1<P_numtype1> > T_expr;
 
3738
 
 
3739
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3740
}
 
3741
 
 
3742
#endif
 
3743
 
 
3744
/****************************************************************************
 
3745
 * erf
 
3746
 ****************************************************************************/
 
3747
 
 
3748
#ifdef BZ_HAVE_IEEE_MATH
 
3749
template<class P_numtype1>
 
3750
inline
 
3751
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3752
    _bz_erf<P_numtype1> > >
 
3753
erf(const Vector<P_numtype1>& d1)
 
3754
{
 
3755
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3756
        _bz_erf<P_numtype1> > T_expr;
 
3757
 
 
3758
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3759
}
 
3760
 
 
3761
template<class P_expr1>
 
3762
inline
 
3763
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3764
    _bz_erf<typename P_expr1::T_numtype> > >
 
3765
erf(_bz_VecExpr<P_expr1> d1)
 
3766
{
 
3767
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3768
        _bz_erf<typename P_expr1::T_numtype> > T_expr;
 
3769
 
 
3770
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3771
}
 
3772
 
 
3773
template<class P_numtype1>
 
3774
inline
 
3775
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3776
    _bz_erf<P_numtype1> > >
 
3777
erf(const VectorPick<P_numtype1>& d1)
 
3778
{
 
3779
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3780
        _bz_erf<P_numtype1> > T_expr;
 
3781
 
 
3782
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3783
}
 
3784
 
 
3785
 
 
3786
inline
 
3787
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
3788
    _bz_erf<int> > >
 
3789
erf(Range d1)
 
3790
{
 
3791
    typedef _bz_VecExprUnaryOp<Range,
 
3792
        _bz_erf<int> > T_expr;
 
3793
 
 
3794
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3795
}
 
3796
 
 
3797
template<class P_numtype1, int N_length1>
 
3798
inline
 
3799
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3800
    _bz_erf<P_numtype1> > >
 
3801
erf(const TinyVector<P_numtype1, N_length1>& d1)
 
3802
{
 
3803
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3804
        _bz_erf<P_numtype1> > T_expr;
 
3805
 
 
3806
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3807
}
 
3808
 
 
3809
#endif
 
3810
 
 
3811
/****************************************************************************
 
3812
 * erfc
 
3813
 ****************************************************************************/
 
3814
 
 
3815
#ifdef BZ_HAVE_IEEE_MATH
 
3816
template<class P_numtype1>
 
3817
inline
 
3818
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3819
    _bz_erfc<P_numtype1> > >
 
3820
erfc(const Vector<P_numtype1>& d1)
 
3821
{
 
3822
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3823
        _bz_erfc<P_numtype1> > T_expr;
 
3824
 
 
3825
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3826
}
 
3827
 
 
3828
template<class P_expr1>
 
3829
inline
 
3830
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3831
    _bz_erfc<typename P_expr1::T_numtype> > >
 
3832
erfc(_bz_VecExpr<P_expr1> d1)
 
3833
{
 
3834
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3835
        _bz_erfc<typename P_expr1::T_numtype> > T_expr;
 
3836
 
 
3837
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3838
}
 
3839
 
 
3840
template<class P_numtype1>
 
3841
inline
 
3842
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3843
    _bz_erfc<P_numtype1> > >
 
3844
erfc(const VectorPick<P_numtype1>& d1)
 
3845
{
 
3846
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3847
        _bz_erfc<P_numtype1> > T_expr;
 
3848
 
 
3849
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3850
}
 
3851
 
 
3852
 
 
3853
inline
 
3854
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
3855
    _bz_erfc<int> > >
 
3856
erfc(Range d1)
 
3857
{
 
3858
    typedef _bz_VecExprUnaryOp<Range,
 
3859
        _bz_erfc<int> > T_expr;
 
3860
 
 
3861
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3862
}
 
3863
 
 
3864
template<class P_numtype1, int N_length1>
 
3865
inline
 
3866
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3867
    _bz_erfc<P_numtype1> > >
 
3868
erfc(const TinyVector<P_numtype1, N_length1>& d1)
 
3869
{
 
3870
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3871
        _bz_erfc<P_numtype1> > T_expr;
 
3872
 
 
3873
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3874
}
 
3875
 
 
3876
#endif
 
3877
 
 
3878
/****************************************************************************
 
3879
 * fabs
 
3880
 ****************************************************************************/
 
3881
 
 
3882
template<class P_numtype1>
 
3883
inline
 
3884
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3885
    _bz_abs<P_numtype1> > >
 
3886
fabs(const Vector<P_numtype1>& d1)
 
3887
{
 
3888
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3889
        _bz_abs<P_numtype1> > T_expr;
 
3890
 
 
3891
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3892
}
 
3893
 
 
3894
template<class P_expr1>
 
3895
inline
 
3896
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3897
    _bz_abs<typename P_expr1::T_numtype> > >
 
3898
fabs(_bz_VecExpr<P_expr1> d1)
 
3899
{
 
3900
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3901
        _bz_abs<typename P_expr1::T_numtype> > T_expr;
 
3902
 
 
3903
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3904
}
 
3905
 
 
3906
template<class P_numtype1>
 
3907
inline
 
3908
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3909
    _bz_abs<P_numtype1> > >
 
3910
fabs(const VectorPick<P_numtype1>& d1)
 
3911
{
 
3912
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3913
        _bz_abs<P_numtype1> > T_expr;
 
3914
 
 
3915
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3916
}
 
3917
 
 
3918
 
 
3919
inline
 
3920
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
3921
    _bz_abs<int> > >
 
3922
fabs(Range d1)
 
3923
{
 
3924
    typedef _bz_VecExprUnaryOp<Range,
 
3925
        _bz_abs<int> > T_expr;
 
3926
 
 
3927
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3928
}
 
3929
 
 
3930
template<class P_numtype1, int N_length1>
 
3931
inline
 
3932
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3933
    _bz_abs<P_numtype1> > >
 
3934
fabs(const TinyVector<P_numtype1, N_length1>& d1)
 
3935
{
 
3936
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3937
        _bz_abs<P_numtype1> > T_expr;
 
3938
 
 
3939
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3940
}
 
3941
 
 
3942
 
 
3943
/****************************************************************************
 
3944
 * floor
 
3945
 ****************************************************************************/
 
3946
 
 
3947
template<class P_numtype1>
 
3948
inline
 
3949
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3950
    _bz_floor<P_numtype1> > >
 
3951
floor(const Vector<P_numtype1>& d1)
 
3952
{
 
3953
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
3954
        _bz_floor<P_numtype1> > T_expr;
 
3955
 
 
3956
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3957
}
 
3958
 
 
3959
template<class P_expr1>
 
3960
inline
 
3961
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3962
    _bz_floor<typename P_expr1::T_numtype> > >
 
3963
floor(_bz_VecExpr<P_expr1> d1)
 
3964
{
 
3965
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
3966
        _bz_floor<typename P_expr1::T_numtype> > T_expr;
 
3967
 
 
3968
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3969
}
 
3970
 
 
3971
template<class P_numtype1>
 
3972
inline
 
3973
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3974
    _bz_floor<P_numtype1> > >
 
3975
floor(const VectorPick<P_numtype1>& d1)
 
3976
{
 
3977
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
3978
        _bz_floor<P_numtype1> > T_expr;
 
3979
 
 
3980
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
3981
}
 
3982
 
 
3983
 
 
3984
inline
 
3985
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
3986
    _bz_floor<int> > >
 
3987
floor(Range d1)
 
3988
{
 
3989
    typedef _bz_VecExprUnaryOp<Range,
 
3990
        _bz_floor<int> > T_expr;
 
3991
 
 
3992
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
3993
}
 
3994
 
 
3995
template<class P_numtype1, int N_length1>
 
3996
inline
 
3997
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
3998
    _bz_floor<P_numtype1> > >
 
3999
floor(const TinyVector<P_numtype1, N_length1>& d1)
 
4000
{
 
4001
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
4002
        _bz_floor<P_numtype1> > T_expr;
 
4003
 
 
4004
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
4005
}
 
4006
 
 
4007
 
 
4008
/****************************************************************************
 
4009
 * fmod
 
4010
 ****************************************************************************/
 
4011
 
 
4012
template<class P_numtype1, class P_numtype2>
 
4013
inline
 
4014
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
4015
    _bz_fmod<P_numtype1,P_numtype2> > >
 
4016
fmod(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
4017
{
 
4018
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
4019
        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
 
4020
 
 
4021
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4022
}
 
4023
 
 
4024
template<class P_numtype1, class P_expr2>
 
4025
inline
 
4026
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
4027
    _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > >
 
4028
fmod(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
4029
{
 
4030
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
4031
        _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
4032
 
 
4033
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
4034
}
 
4035
 
 
4036
template<class P_numtype1, class P_numtype2>
 
4037
inline
 
4038
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
4039
    _bz_fmod<P_numtype1,P_numtype2> > >
 
4040
fmod(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
4041
{
 
4042
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
4043
        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
 
4044
 
 
4045
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4046
}
 
4047
 
 
4048
template<class P_numtype1>
 
4049
inline
 
4050
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
4051
    _bz_fmod<P_numtype1,int> > >
 
4052
fmod(const Vector<P_numtype1>& d1, Range d2)
 
4053
{
 
4054
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
4055
        _bz_fmod<P_numtype1,int> > T_expr;
 
4056
 
 
4057
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
4058
}
 
4059
 
 
4060
template<class P_numtype1, class P_numtype2, int N_length2>
 
4061
inline
 
4062
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4063
    _bz_fmod<P_numtype1,P_numtype2> > >
 
4064
fmod(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4065
{
 
4066
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4067
        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
 
4068
 
 
4069
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4070
}
 
4071
 
 
4072
template<class P_numtype1>
 
4073
inline
 
4074
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
4075
    _bz_fmod<P_numtype1,int> > >
 
4076
fmod(const Vector<P_numtype1>& d1, int d2)
 
4077
{
 
4078
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
4079
        _bz_fmod<P_numtype1,int> > T_expr;
 
4080
 
 
4081
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
4082
}
 
4083
 
 
4084
template<class P_numtype1>
 
4085
inline
 
4086
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
4087
    _bz_fmod<P_numtype1,float> > >
 
4088
fmod(const Vector<P_numtype1>& d1, float d2)
 
4089
{
 
4090
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
4091
        _bz_fmod<P_numtype1,float> > T_expr;
 
4092
 
 
4093
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
4094
}
 
4095
 
 
4096
template<class P_numtype1>
 
4097
inline
 
4098
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
4099
    _bz_fmod<P_numtype1,double> > >
 
4100
fmod(const Vector<P_numtype1>& d1, double d2)
 
4101
{
 
4102
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
4103
        _bz_fmod<P_numtype1,double> > T_expr;
 
4104
 
 
4105
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
4106
}
 
4107
 
 
4108
template<class P_numtype1>
 
4109
inline
 
4110
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
4111
    _bz_fmod<P_numtype1,long double> > >
 
4112
fmod(const Vector<P_numtype1>& d1, long double d2)
 
4113
{
 
4114
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
4115
        _bz_fmod<P_numtype1,long double> > T_expr;
 
4116
 
 
4117
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
4118
}
 
4119
 
 
4120
template<class P_numtype1, class T2>
 
4121
inline
 
4122
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
4123
    _bz_fmod<P_numtype1,complex<T2> > > >
 
4124
fmod(const Vector<P_numtype1>& d1, complex<T2> d2)
 
4125
{
 
4126
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
4127
        _bz_fmod<P_numtype1,complex<T2> > > T_expr;
 
4128
 
 
4129
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
4130
}
 
4131
 
 
4132
template<class P_expr1, class P_numtype2>
 
4133
inline
 
4134
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
4135
    _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > >
 
4136
fmod(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
 
4137
{
 
4138
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
4139
        _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
4140
 
 
4141
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
4142
}
 
4143
 
 
4144
template<class P_expr1, class P_expr2>
 
4145
inline
 
4146
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
4147
    _bz_fmod<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
 
4148
fmod(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
 
4149
{
 
4150
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
4151
        _bz_fmod<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
 
4152
 
 
4153
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
4154
}
 
4155
 
 
4156
template<class P_expr1, class P_numtype2>
 
4157
inline
 
4158
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
4159
    _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > >
 
4160
fmod(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
 
4161
{
 
4162
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
4163
        _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
4164
 
 
4165
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
4166
}
 
4167
 
 
4168
template<class P_expr1>
 
4169
inline
 
4170
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
4171
    _bz_fmod<typename P_expr1::T_numtype,int> > >
 
4172
fmod(_bz_VecExpr<P_expr1> d1, Range d2)
 
4173
{
 
4174
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
4175
        _bz_fmod<typename P_expr1::T_numtype,int> > T_expr;
 
4176
 
 
4177
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
4178
}
 
4179
 
 
4180
template<class P_expr1, class P_numtype2, int N_length2>
 
4181
inline
 
4182
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4183
    _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > >
 
4184
fmod(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4185
{
 
4186
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4187
        _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
4188
 
 
4189
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
4190
}
 
4191
 
 
4192
template<class P_expr1>
 
4193
inline
 
4194
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
4195
    _bz_fmod<typename P_expr1::T_numtype,int> > >
 
4196
fmod(_bz_VecExpr<P_expr1> d1, int d2)
 
4197
{
 
4198
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
4199
        _bz_fmod<typename P_expr1::T_numtype,int> > T_expr;
 
4200
 
 
4201
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
4202
}
 
4203
 
 
4204
template<class P_expr1>
 
4205
inline
 
4206
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
4207
    _bz_fmod<typename P_expr1::T_numtype,float> > >
 
4208
fmod(_bz_VecExpr<P_expr1> d1, float d2)
 
4209
{
 
4210
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
4211
        _bz_fmod<typename P_expr1::T_numtype,float> > T_expr;
 
4212
 
 
4213
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
4214
}
 
4215
 
 
4216
template<class P_expr1>
 
4217
inline
 
4218
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
4219
    _bz_fmod<typename P_expr1::T_numtype,double> > >
 
4220
fmod(_bz_VecExpr<P_expr1> d1, double d2)
 
4221
{
 
4222
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
4223
        _bz_fmod<typename P_expr1::T_numtype,double> > T_expr;
 
4224
 
 
4225
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
4226
}
 
4227
 
 
4228
template<class P_expr1>
 
4229
inline
 
4230
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
4231
    _bz_fmod<typename P_expr1::T_numtype,long double> > >
 
4232
fmod(_bz_VecExpr<P_expr1> d1, long double d2)
 
4233
{
 
4234
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
4235
        _bz_fmod<typename P_expr1::T_numtype,long double> > T_expr;
 
4236
 
 
4237
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
4238
}
 
4239
 
 
4240
template<class P_expr1, class T2>
 
4241
inline
 
4242
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
4243
    _bz_fmod<typename P_expr1::T_numtype,complex<T2> > > >
 
4244
fmod(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
 
4245
{
 
4246
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
4247
        _bz_fmod<typename P_expr1::T_numtype,complex<T2> > > T_expr;
 
4248
 
 
4249
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
4250
}
 
4251
 
 
4252
template<class P_numtype1, class P_numtype2>
 
4253
inline
 
4254
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
4255
    _bz_fmod<P_numtype1,P_numtype2> > >
 
4256
fmod(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
4257
{
 
4258
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
4259
        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
 
4260
 
 
4261
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4262
}
 
4263
 
 
4264
template<class P_numtype1, class P_expr2>
 
4265
inline
 
4266
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
4267
    _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > >
 
4268
fmod(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
4269
{
 
4270
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
4271
        _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
4272
 
 
4273
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
4274
}
 
4275
 
 
4276
template<class P_numtype1, class P_numtype2>
 
4277
inline
 
4278
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
4279
    _bz_fmod<P_numtype1,P_numtype2> > >
 
4280
fmod(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
4281
{
 
4282
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
4283
        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
 
4284
 
 
4285
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4286
}
 
4287
 
 
4288
template<class P_numtype1>
 
4289
inline
 
4290
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
4291
    _bz_fmod<P_numtype1,int> > >
 
4292
fmod(const VectorPick<P_numtype1>& d1, Range d2)
 
4293
{
 
4294
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
4295
        _bz_fmod<P_numtype1,int> > T_expr;
 
4296
 
 
4297
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
4298
}
 
4299
 
 
4300
template<class P_numtype1, class P_numtype2, int N_length2>
 
4301
inline
 
4302
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4303
    _bz_fmod<P_numtype1,P_numtype2> > >
 
4304
fmod(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4305
{
 
4306
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4307
        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
 
4308
 
 
4309
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4310
}
 
4311
 
 
4312
template<class P_numtype1>
 
4313
inline
 
4314
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
4315
    _bz_fmod<P_numtype1,int> > >
 
4316
fmod(const VectorPick<P_numtype1>& d1, int d2)
 
4317
{
 
4318
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
4319
        _bz_fmod<P_numtype1,int> > T_expr;
 
4320
 
 
4321
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
4322
}
 
4323
 
 
4324
template<class P_numtype1>
 
4325
inline
 
4326
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
4327
    _bz_fmod<P_numtype1,float> > >
 
4328
fmod(const VectorPick<P_numtype1>& d1, float d2)
 
4329
{
 
4330
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
4331
        _bz_fmod<P_numtype1,float> > T_expr;
 
4332
 
 
4333
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
4334
}
 
4335
 
 
4336
template<class P_numtype1>
 
4337
inline
 
4338
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
4339
    _bz_fmod<P_numtype1,double> > >
 
4340
fmod(const VectorPick<P_numtype1>& d1, double d2)
 
4341
{
 
4342
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
4343
        _bz_fmod<P_numtype1,double> > T_expr;
 
4344
 
 
4345
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
4346
}
 
4347
 
 
4348
template<class P_numtype1>
 
4349
inline
 
4350
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
4351
    _bz_fmod<P_numtype1,long double> > >
 
4352
fmod(const VectorPick<P_numtype1>& d1, long double d2)
 
4353
{
 
4354
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
4355
        _bz_fmod<P_numtype1,long double> > T_expr;
 
4356
 
 
4357
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
4358
}
 
4359
 
 
4360
template<class P_numtype1, class T2>
 
4361
inline
 
4362
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
4363
    _bz_fmod<P_numtype1,complex<T2> > > >
 
4364
fmod(const VectorPick<P_numtype1>& d1, complex<T2> d2)
 
4365
{
 
4366
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
4367
        _bz_fmod<P_numtype1,complex<T2> > > T_expr;
 
4368
 
 
4369
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
4370
}
 
4371
 
 
4372
template<class P_numtype2>
 
4373
inline
 
4374
_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
4375
    _bz_fmod<int,P_numtype2> > >
 
4376
fmod(Range d1, const Vector<P_numtype2>& d2)
 
4377
{
 
4378
    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
4379
        _bz_fmod<int,P_numtype2> > T_expr;
 
4380
 
 
4381
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
4382
}
 
4383
 
 
4384
template<class P_expr2>
 
4385
inline
 
4386
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
4387
    _bz_fmod<int,typename P_expr2::T_numtype> > >
 
4388
fmod(Range d1, _bz_VecExpr<P_expr2> d2)
 
4389
{
 
4390
    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
4391
        _bz_fmod<int,typename P_expr2::T_numtype> > T_expr;
 
4392
 
 
4393
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
4394
}
 
4395
 
 
4396
template<class P_numtype2>
 
4397
inline
 
4398
_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
4399
    _bz_fmod<int,P_numtype2> > >
 
4400
fmod(Range d1, const VectorPick<P_numtype2>& d2)
 
4401
{
 
4402
    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
4403
        _bz_fmod<int,P_numtype2> > T_expr;
 
4404
 
 
4405
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
4406
}
 
4407
 
 
4408
 
 
4409
inline
 
4410
_bz_VecExpr<_bz_VecExprOp<Range, Range,
 
4411
    _bz_fmod<int,int> > >
 
4412
fmod(Range d1, Range d2)
 
4413
{
 
4414
    typedef _bz_VecExprOp<Range, Range,
 
4415
        _bz_fmod<int,int> > T_expr;
 
4416
 
 
4417
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
4418
}
 
4419
 
 
4420
template<class P_numtype2, int N_length2>
 
4421
inline
 
4422
_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
4423
    _bz_fmod<int,P_numtype2> > >
 
4424
fmod(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4425
{
 
4426
    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
4427
        _bz_fmod<int,P_numtype2> > T_expr;
 
4428
 
 
4429
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
4430
}
 
4431
 
 
4432
 
 
4433
inline
 
4434
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
4435
    _bz_fmod<int,int> > >
 
4436
fmod(Range d1, int d2)
 
4437
{
 
4438
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
4439
        _bz_fmod<int,int> > T_expr;
 
4440
 
 
4441
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
4442
}
 
4443
 
 
4444
 
 
4445
inline
 
4446
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
4447
    _bz_fmod<int,float> > >
 
4448
fmod(Range d1, float d2)
 
4449
{
 
4450
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
4451
        _bz_fmod<int,float> > T_expr;
 
4452
 
 
4453
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
4454
}
 
4455
 
 
4456
 
 
4457
inline
 
4458
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
4459
    _bz_fmod<int,double> > >
 
4460
fmod(Range d1, double d2)
 
4461
{
 
4462
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
4463
        _bz_fmod<int,double> > T_expr;
 
4464
 
 
4465
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
4466
}
 
4467
 
 
4468
 
 
4469
inline
 
4470
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
4471
    _bz_fmod<int,long double> > >
 
4472
fmod(Range d1, long double d2)
 
4473
{
 
4474
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
4475
        _bz_fmod<int,long double> > T_expr;
 
4476
 
 
4477
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
4478
}
 
4479
 
 
4480
template<class T2>
 
4481
inline
 
4482
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
4483
    _bz_fmod<int,complex<T2> > > >
 
4484
fmod(Range d1, complex<T2> d2)
 
4485
{
 
4486
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
4487
        _bz_fmod<int,complex<T2> > > T_expr;
 
4488
 
 
4489
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
4490
}
 
4491
 
 
4492
template<class P_numtype1, int N_length1, class P_numtype2>
 
4493
inline
 
4494
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
4495
    _bz_fmod<P_numtype1,P_numtype2> > >
 
4496
fmod(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
 
4497
{
 
4498
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
4499
        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
 
4500
 
 
4501
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4502
}
 
4503
 
 
4504
template<class P_numtype1, int N_length1, class P_expr2>
 
4505
inline
 
4506
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
4507
    _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > >
 
4508
fmod(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
 
4509
{
 
4510
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
4511
        _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
4512
 
 
4513
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
4514
}
 
4515
 
 
4516
template<class P_numtype1, int N_length1, class P_numtype2>
 
4517
inline
 
4518
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
4519
    _bz_fmod<P_numtype1,P_numtype2> > >
 
4520
fmod(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
 
4521
{
 
4522
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
4523
        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
 
4524
 
 
4525
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4526
}
 
4527
 
 
4528
template<class P_numtype1, int N_length1>
 
4529
inline
 
4530
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
4531
    _bz_fmod<P_numtype1,int> > >
 
4532
fmod(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
 
4533
{
 
4534
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
4535
        _bz_fmod<P_numtype1,int> > T_expr;
 
4536
 
 
4537
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
4538
}
 
4539
 
 
4540
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
 
4541
inline
 
4542
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4543
    _bz_fmod<P_numtype1,P_numtype2> > >
 
4544
fmod(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4545
{
 
4546
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4547
        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
 
4548
 
 
4549
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4550
}
 
4551
 
 
4552
template<class P_numtype1, int N_length1>
 
4553
inline
 
4554
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
4555
    _bz_fmod<P_numtype1,int> > >
 
4556
fmod(const TinyVector<P_numtype1, N_length1>& d1, int d2)
 
4557
{
 
4558
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
4559
        _bz_fmod<P_numtype1,int> > T_expr;
 
4560
 
 
4561
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
4562
}
 
4563
 
 
4564
template<class P_numtype1, int N_length1>
 
4565
inline
 
4566
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
4567
    _bz_fmod<P_numtype1,float> > >
 
4568
fmod(const TinyVector<P_numtype1, N_length1>& d1, float d2)
 
4569
{
 
4570
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
4571
        _bz_fmod<P_numtype1,float> > T_expr;
 
4572
 
 
4573
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
4574
}
 
4575
 
 
4576
template<class P_numtype1, int N_length1>
 
4577
inline
 
4578
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
4579
    _bz_fmod<P_numtype1,double> > >
 
4580
fmod(const TinyVector<P_numtype1, N_length1>& d1, double d2)
 
4581
{
 
4582
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
4583
        _bz_fmod<P_numtype1,double> > T_expr;
 
4584
 
 
4585
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
4586
}
 
4587
 
 
4588
template<class P_numtype1, int N_length1>
 
4589
inline
 
4590
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
4591
    _bz_fmod<P_numtype1,long double> > >
 
4592
fmod(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
 
4593
{
 
4594
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
4595
        _bz_fmod<P_numtype1,long double> > T_expr;
 
4596
 
 
4597
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
4598
}
 
4599
 
 
4600
template<class P_numtype1, int N_length1, class T2>
 
4601
inline
 
4602
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
4603
    _bz_fmod<P_numtype1,complex<T2> > > >
 
4604
fmod(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
 
4605
{
 
4606
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
4607
        _bz_fmod<P_numtype1,complex<T2> > > T_expr;
 
4608
 
 
4609
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
4610
}
 
4611
 
 
4612
template<class P_numtype2>
 
4613
inline
 
4614
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
4615
    _bz_fmod<int,P_numtype2> > >
 
4616
fmod(int d1, const Vector<P_numtype2>& d2)
 
4617
{
 
4618
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
4619
        _bz_fmod<int,P_numtype2> > T_expr;
 
4620
 
 
4621
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
4622
}
 
4623
 
 
4624
template<class P_expr2>
 
4625
inline
 
4626
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
4627
    _bz_fmod<int,typename P_expr2::T_numtype> > >
 
4628
fmod(int d1, _bz_VecExpr<P_expr2> d2)
 
4629
{
 
4630
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
4631
        _bz_fmod<int,typename P_expr2::T_numtype> > T_expr;
 
4632
 
 
4633
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
4634
}
 
4635
 
 
4636
template<class P_numtype2>
 
4637
inline
 
4638
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
4639
    _bz_fmod<int,P_numtype2> > >
 
4640
fmod(int d1, const VectorPick<P_numtype2>& d2)
 
4641
{
 
4642
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
4643
        _bz_fmod<int,P_numtype2> > T_expr;
 
4644
 
 
4645
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
4646
}
 
4647
 
 
4648
 
 
4649
inline
 
4650
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
4651
    _bz_fmod<int,int> > >
 
4652
fmod(int d1, Range d2)
 
4653
{
 
4654
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
4655
        _bz_fmod<int,int> > T_expr;
 
4656
 
 
4657
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
4658
}
 
4659
 
 
4660
template<class P_numtype2, int N_length2>
 
4661
inline
 
4662
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4663
    _bz_fmod<int,P_numtype2> > >
 
4664
fmod(int d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4665
{
 
4666
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4667
        _bz_fmod<int,P_numtype2> > T_expr;
 
4668
 
 
4669
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
4670
}
 
4671
 
 
4672
template<class P_numtype2>
 
4673
inline
 
4674
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
4675
    _bz_fmod<float,P_numtype2> > >
 
4676
fmod(float d1, const Vector<P_numtype2>& d2)
 
4677
{
 
4678
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
4679
        _bz_fmod<float,P_numtype2> > T_expr;
 
4680
 
 
4681
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
4682
}
 
4683
 
 
4684
template<class P_expr2>
 
4685
inline
 
4686
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
4687
    _bz_fmod<float,typename P_expr2::T_numtype> > >
 
4688
fmod(float d1, _bz_VecExpr<P_expr2> d2)
 
4689
{
 
4690
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
4691
        _bz_fmod<float,typename P_expr2::T_numtype> > T_expr;
 
4692
 
 
4693
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
4694
}
 
4695
 
 
4696
template<class P_numtype2>
 
4697
inline
 
4698
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
4699
    _bz_fmod<float,P_numtype2> > >
 
4700
fmod(float d1, const VectorPick<P_numtype2>& d2)
 
4701
{
 
4702
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
4703
        _bz_fmod<float,P_numtype2> > T_expr;
 
4704
 
 
4705
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
4706
}
 
4707
 
 
4708
 
 
4709
inline
 
4710
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
4711
    _bz_fmod<float,int> > >
 
4712
fmod(float d1, Range d2)
 
4713
{
 
4714
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
4715
        _bz_fmod<float,int> > T_expr;
 
4716
 
 
4717
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
4718
}
 
4719
 
 
4720
template<class P_numtype2, int N_length2>
 
4721
inline
 
4722
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4723
    _bz_fmod<float,P_numtype2> > >
 
4724
fmod(float d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4725
{
 
4726
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4727
        _bz_fmod<float,P_numtype2> > T_expr;
 
4728
 
 
4729
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
4730
}
 
4731
 
 
4732
template<class P_numtype2>
 
4733
inline
 
4734
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
4735
    _bz_fmod<double,P_numtype2> > >
 
4736
fmod(double d1, const Vector<P_numtype2>& d2)
 
4737
{
 
4738
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
4739
        _bz_fmod<double,P_numtype2> > T_expr;
 
4740
 
 
4741
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
4742
}
 
4743
 
 
4744
template<class P_expr2>
 
4745
inline
 
4746
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
4747
    _bz_fmod<double,typename P_expr2::T_numtype> > >
 
4748
fmod(double d1, _bz_VecExpr<P_expr2> d2)
 
4749
{
 
4750
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
4751
        _bz_fmod<double,typename P_expr2::T_numtype> > T_expr;
 
4752
 
 
4753
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
4754
}
 
4755
 
 
4756
template<class P_numtype2>
 
4757
inline
 
4758
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
4759
    _bz_fmod<double,P_numtype2> > >
 
4760
fmod(double d1, const VectorPick<P_numtype2>& d2)
 
4761
{
 
4762
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
4763
        _bz_fmod<double,P_numtype2> > T_expr;
 
4764
 
 
4765
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
4766
}
 
4767
 
 
4768
 
 
4769
inline
 
4770
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
4771
    _bz_fmod<double,int> > >
 
4772
fmod(double d1, Range d2)
 
4773
{
 
4774
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
4775
        _bz_fmod<double,int> > T_expr;
 
4776
 
 
4777
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
4778
}
 
4779
 
 
4780
template<class P_numtype2, int N_length2>
 
4781
inline
 
4782
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4783
    _bz_fmod<double,P_numtype2> > >
 
4784
fmod(double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4785
{
 
4786
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4787
        _bz_fmod<double,P_numtype2> > T_expr;
 
4788
 
 
4789
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
4790
}
 
4791
 
 
4792
template<class P_numtype2>
 
4793
inline
 
4794
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
4795
    _bz_fmod<long double,P_numtype2> > >
 
4796
fmod(long double d1, const Vector<P_numtype2>& d2)
 
4797
{
 
4798
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
4799
        _bz_fmod<long double,P_numtype2> > T_expr;
 
4800
 
 
4801
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
4802
}
 
4803
 
 
4804
template<class P_expr2>
 
4805
inline
 
4806
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
4807
    _bz_fmod<long double,typename P_expr2::T_numtype> > >
 
4808
fmod(long double d1, _bz_VecExpr<P_expr2> d2)
 
4809
{
 
4810
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
4811
        _bz_fmod<long double,typename P_expr2::T_numtype> > T_expr;
 
4812
 
 
4813
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
4814
}
 
4815
 
 
4816
template<class P_numtype2>
 
4817
inline
 
4818
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
4819
    _bz_fmod<long double,P_numtype2> > >
 
4820
fmod(long double d1, const VectorPick<P_numtype2>& d2)
 
4821
{
 
4822
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
4823
        _bz_fmod<long double,P_numtype2> > T_expr;
 
4824
 
 
4825
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
4826
}
 
4827
 
 
4828
 
 
4829
inline
 
4830
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
4831
    _bz_fmod<long double,int> > >
 
4832
fmod(long double d1, Range d2)
 
4833
{
 
4834
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
4835
        _bz_fmod<long double,int> > T_expr;
 
4836
 
 
4837
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
4838
}
 
4839
 
 
4840
template<class P_numtype2, int N_length2>
 
4841
inline
 
4842
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4843
    _bz_fmod<long double,P_numtype2> > >
 
4844
fmod(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4845
{
 
4846
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4847
        _bz_fmod<long double,P_numtype2> > T_expr;
 
4848
 
 
4849
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
4850
}
 
4851
 
 
4852
template<class T1, class P_numtype2>
 
4853
inline
 
4854
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
4855
    _bz_fmod<complex<T1> ,P_numtype2> > >
 
4856
fmod(complex<T1> d1, const Vector<P_numtype2>& d2)
 
4857
{
 
4858
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
4859
        _bz_fmod<complex<T1> ,P_numtype2> > T_expr;
 
4860
 
 
4861
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
4862
}
 
4863
 
 
4864
template<class T1, class P_expr2>
 
4865
inline
 
4866
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
4867
    _bz_fmod<complex<T1> ,typename P_expr2::T_numtype> > >
 
4868
fmod(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
 
4869
{
 
4870
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
4871
        _bz_fmod<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
 
4872
 
 
4873
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
4874
}
 
4875
 
 
4876
template<class T1, class P_numtype2>
 
4877
inline
 
4878
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
4879
    _bz_fmod<complex<T1> ,P_numtype2> > >
 
4880
fmod(complex<T1> d1, const VectorPick<P_numtype2>& d2)
 
4881
{
 
4882
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
4883
        _bz_fmod<complex<T1> ,P_numtype2> > T_expr;
 
4884
 
 
4885
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
4886
}
 
4887
 
 
4888
template<class T1>
 
4889
inline
 
4890
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
4891
    _bz_fmod<complex<T1> ,int> > >
 
4892
fmod(complex<T1> d1, Range d2)
 
4893
{
 
4894
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
4895
        _bz_fmod<complex<T1> ,int> > T_expr;
 
4896
 
 
4897
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
4898
}
 
4899
 
 
4900
template<class T1, class P_numtype2, int N_length2>
 
4901
inline
 
4902
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
4903
    _bz_fmod<complex<T1> ,P_numtype2> > >
 
4904
fmod(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4905
{
 
4906
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
4907
        _bz_fmod<complex<T1> ,P_numtype2> > T_expr;
 
4908
 
 
4909
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
4910
}
 
4911
 
 
4912
 
 
4913
/****************************************************************************
 
4914
 * hypot
 
4915
 ****************************************************************************/
 
4916
 
 
4917
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
4918
template<class P_numtype1, class P_numtype2>
 
4919
inline
 
4920
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
4921
    _bz_hypot<P_numtype1,P_numtype2> > >
 
4922
hypot(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
4923
{
 
4924
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
4925
        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
 
4926
 
 
4927
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4928
}
 
4929
 
 
4930
template<class P_numtype1, class P_expr2>
 
4931
inline
 
4932
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
4933
    _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > >
 
4934
hypot(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
4935
{
 
4936
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
4937
        _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
4938
 
 
4939
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
4940
}
 
4941
 
 
4942
template<class P_numtype1, class P_numtype2>
 
4943
inline
 
4944
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
4945
    _bz_hypot<P_numtype1,P_numtype2> > >
 
4946
hypot(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
4947
{
 
4948
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
4949
        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
 
4950
 
 
4951
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4952
}
 
4953
 
 
4954
template<class P_numtype1>
 
4955
inline
 
4956
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
4957
    _bz_hypot<P_numtype1,int> > >
 
4958
hypot(const Vector<P_numtype1>& d1, Range d2)
 
4959
{
 
4960
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
4961
        _bz_hypot<P_numtype1,int> > T_expr;
 
4962
 
 
4963
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
4964
}
 
4965
 
 
4966
template<class P_numtype1, class P_numtype2, int N_length2>
 
4967
inline
 
4968
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4969
    _bz_hypot<P_numtype1,P_numtype2> > >
 
4970
hypot(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
4971
{
 
4972
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
4973
        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
 
4974
 
 
4975
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
4976
}
 
4977
 
 
4978
template<class P_numtype1>
 
4979
inline
 
4980
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
4981
    _bz_hypot<P_numtype1,int> > >
 
4982
hypot(const Vector<P_numtype1>& d1, int d2)
 
4983
{
 
4984
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
4985
        _bz_hypot<P_numtype1,int> > T_expr;
 
4986
 
 
4987
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
4988
}
 
4989
 
 
4990
template<class P_numtype1>
 
4991
inline
 
4992
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
4993
    _bz_hypot<P_numtype1,float> > >
 
4994
hypot(const Vector<P_numtype1>& d1, float d2)
 
4995
{
 
4996
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
4997
        _bz_hypot<P_numtype1,float> > T_expr;
 
4998
 
 
4999
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
5000
}
 
5001
 
 
5002
template<class P_numtype1>
 
5003
inline
 
5004
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
5005
    _bz_hypot<P_numtype1,double> > >
 
5006
hypot(const Vector<P_numtype1>& d1, double d2)
 
5007
{
 
5008
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
5009
        _bz_hypot<P_numtype1,double> > T_expr;
 
5010
 
 
5011
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
5012
}
 
5013
 
 
5014
template<class P_numtype1>
 
5015
inline
 
5016
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
5017
    _bz_hypot<P_numtype1,long double> > >
 
5018
hypot(const Vector<P_numtype1>& d1, long double d2)
 
5019
{
 
5020
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
5021
        _bz_hypot<P_numtype1,long double> > T_expr;
 
5022
 
 
5023
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
5024
}
 
5025
 
 
5026
template<class P_numtype1, class T2>
 
5027
inline
 
5028
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
5029
    _bz_hypot<P_numtype1,complex<T2> > > >
 
5030
hypot(const Vector<P_numtype1>& d1, complex<T2> d2)
 
5031
{
 
5032
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
5033
        _bz_hypot<P_numtype1,complex<T2> > > T_expr;
 
5034
 
 
5035
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
5036
}
 
5037
 
 
5038
template<class P_expr1, class P_numtype2>
 
5039
inline
 
5040
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
5041
    _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > >
 
5042
hypot(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
 
5043
{
 
5044
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
5045
        _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
5046
 
 
5047
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
5048
}
 
5049
 
 
5050
template<class P_expr1, class P_expr2>
 
5051
inline
 
5052
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
5053
    _bz_hypot<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
 
5054
hypot(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
 
5055
{
 
5056
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
5057
        _bz_hypot<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
 
5058
 
 
5059
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
5060
}
 
5061
 
 
5062
template<class P_expr1, class P_numtype2>
 
5063
inline
 
5064
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
5065
    _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > >
 
5066
hypot(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
 
5067
{
 
5068
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
5069
        _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
5070
 
 
5071
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
5072
}
 
5073
 
 
5074
template<class P_expr1>
 
5075
inline
 
5076
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
5077
    _bz_hypot<typename P_expr1::T_numtype,int> > >
 
5078
hypot(_bz_VecExpr<P_expr1> d1, Range d2)
 
5079
{
 
5080
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
5081
        _bz_hypot<typename P_expr1::T_numtype,int> > T_expr;
 
5082
 
 
5083
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
5084
}
 
5085
 
 
5086
template<class P_expr1, class P_numtype2, int N_length2>
 
5087
inline
 
5088
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5089
    _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > >
 
5090
hypot(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
5091
{
 
5092
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5093
        _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
5094
 
 
5095
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
5096
}
 
5097
 
 
5098
template<class P_expr1>
 
5099
inline
 
5100
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
5101
    _bz_hypot<typename P_expr1::T_numtype,int> > >
 
5102
hypot(_bz_VecExpr<P_expr1> d1, int d2)
 
5103
{
 
5104
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
5105
        _bz_hypot<typename P_expr1::T_numtype,int> > T_expr;
 
5106
 
 
5107
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
5108
}
 
5109
 
 
5110
template<class P_expr1>
 
5111
inline
 
5112
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
5113
    _bz_hypot<typename P_expr1::T_numtype,float> > >
 
5114
hypot(_bz_VecExpr<P_expr1> d1, float d2)
 
5115
{
 
5116
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
5117
        _bz_hypot<typename P_expr1::T_numtype,float> > T_expr;
 
5118
 
 
5119
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
5120
}
 
5121
 
 
5122
template<class P_expr1>
 
5123
inline
 
5124
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
5125
    _bz_hypot<typename P_expr1::T_numtype,double> > >
 
5126
hypot(_bz_VecExpr<P_expr1> d1, double d2)
 
5127
{
 
5128
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
5129
        _bz_hypot<typename P_expr1::T_numtype,double> > T_expr;
 
5130
 
 
5131
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
5132
}
 
5133
 
 
5134
template<class P_expr1>
 
5135
inline
 
5136
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
5137
    _bz_hypot<typename P_expr1::T_numtype,long double> > >
 
5138
hypot(_bz_VecExpr<P_expr1> d1, long double d2)
 
5139
{
 
5140
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
5141
        _bz_hypot<typename P_expr1::T_numtype,long double> > T_expr;
 
5142
 
 
5143
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
5144
}
 
5145
 
 
5146
template<class P_expr1, class T2>
 
5147
inline
 
5148
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
5149
    _bz_hypot<typename P_expr1::T_numtype,complex<T2> > > >
 
5150
hypot(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
 
5151
{
 
5152
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
5153
        _bz_hypot<typename P_expr1::T_numtype,complex<T2> > > T_expr;
 
5154
 
 
5155
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
5156
}
 
5157
 
 
5158
template<class P_numtype1, class P_numtype2>
 
5159
inline
 
5160
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
5161
    _bz_hypot<P_numtype1,P_numtype2> > >
 
5162
hypot(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
5163
{
 
5164
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
5165
        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
 
5166
 
 
5167
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
5168
}
 
5169
 
 
5170
template<class P_numtype1, class P_expr2>
 
5171
inline
 
5172
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
5173
    _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > >
 
5174
hypot(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
5175
{
 
5176
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
5177
        _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
5178
 
 
5179
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
5180
}
 
5181
 
 
5182
template<class P_numtype1, class P_numtype2>
 
5183
inline
 
5184
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
5185
    _bz_hypot<P_numtype1,P_numtype2> > >
 
5186
hypot(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
5187
{
 
5188
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
5189
        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
 
5190
 
 
5191
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
5192
}
 
5193
 
 
5194
template<class P_numtype1>
 
5195
inline
 
5196
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
5197
    _bz_hypot<P_numtype1,int> > >
 
5198
hypot(const VectorPick<P_numtype1>& d1, Range d2)
 
5199
{
 
5200
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
5201
        _bz_hypot<P_numtype1,int> > T_expr;
 
5202
 
 
5203
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
5204
}
 
5205
 
 
5206
template<class P_numtype1, class P_numtype2, int N_length2>
 
5207
inline
 
5208
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5209
    _bz_hypot<P_numtype1,P_numtype2> > >
 
5210
hypot(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
5211
{
 
5212
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5213
        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
 
5214
 
 
5215
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
5216
}
 
5217
 
 
5218
template<class P_numtype1>
 
5219
inline
 
5220
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
5221
    _bz_hypot<P_numtype1,int> > >
 
5222
hypot(const VectorPick<P_numtype1>& d1, int d2)
 
5223
{
 
5224
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
5225
        _bz_hypot<P_numtype1,int> > T_expr;
 
5226
 
 
5227
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
5228
}
 
5229
 
 
5230
template<class P_numtype1>
 
5231
inline
 
5232
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
5233
    _bz_hypot<P_numtype1,float> > >
 
5234
hypot(const VectorPick<P_numtype1>& d1, float d2)
 
5235
{
 
5236
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
5237
        _bz_hypot<P_numtype1,float> > T_expr;
 
5238
 
 
5239
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
5240
}
 
5241
 
 
5242
template<class P_numtype1>
 
5243
inline
 
5244
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
5245
    _bz_hypot<P_numtype1,double> > >
 
5246
hypot(const VectorPick<P_numtype1>& d1, double d2)
 
5247
{
 
5248
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
5249
        _bz_hypot<P_numtype1,double> > T_expr;
 
5250
 
 
5251
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
5252
}
 
5253
 
 
5254
template<class P_numtype1>
 
5255
inline
 
5256
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
5257
    _bz_hypot<P_numtype1,long double> > >
 
5258
hypot(const VectorPick<P_numtype1>& d1, long double d2)
 
5259
{
 
5260
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
5261
        _bz_hypot<P_numtype1,long double> > T_expr;
 
5262
 
 
5263
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
5264
}
 
5265
 
 
5266
template<class P_numtype1, class T2>
 
5267
inline
 
5268
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
5269
    _bz_hypot<P_numtype1,complex<T2> > > >
 
5270
hypot(const VectorPick<P_numtype1>& d1, complex<T2> d2)
 
5271
{
 
5272
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
5273
        _bz_hypot<P_numtype1,complex<T2> > > T_expr;
 
5274
 
 
5275
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
5276
}
 
5277
 
 
5278
template<class P_numtype2>
 
5279
inline
 
5280
_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
5281
    _bz_hypot<int,P_numtype2> > >
 
5282
hypot(Range d1, const Vector<P_numtype2>& d2)
 
5283
{
 
5284
    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
5285
        _bz_hypot<int,P_numtype2> > T_expr;
 
5286
 
 
5287
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
5288
}
 
5289
 
 
5290
template<class P_expr2>
 
5291
inline
 
5292
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
5293
    _bz_hypot<int,typename P_expr2::T_numtype> > >
 
5294
hypot(Range d1, _bz_VecExpr<P_expr2> d2)
 
5295
{
 
5296
    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
5297
        _bz_hypot<int,typename P_expr2::T_numtype> > T_expr;
 
5298
 
 
5299
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
5300
}
 
5301
 
 
5302
template<class P_numtype2>
 
5303
inline
 
5304
_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
5305
    _bz_hypot<int,P_numtype2> > >
 
5306
hypot(Range d1, const VectorPick<P_numtype2>& d2)
 
5307
{
 
5308
    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
5309
        _bz_hypot<int,P_numtype2> > T_expr;
 
5310
 
 
5311
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
5312
}
 
5313
 
 
5314
 
 
5315
inline
 
5316
_bz_VecExpr<_bz_VecExprOp<Range, Range,
 
5317
    _bz_hypot<int,int> > >
 
5318
hypot(Range d1, Range d2)
 
5319
{
 
5320
    typedef _bz_VecExprOp<Range, Range,
 
5321
        _bz_hypot<int,int> > T_expr;
 
5322
 
 
5323
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
5324
}
 
5325
 
 
5326
template<class P_numtype2, int N_length2>
 
5327
inline
 
5328
_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
5329
    _bz_hypot<int,P_numtype2> > >
 
5330
hypot(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
 
5331
{
 
5332
    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
5333
        _bz_hypot<int,P_numtype2> > T_expr;
 
5334
 
 
5335
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
5336
}
 
5337
 
 
5338
 
 
5339
inline
 
5340
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
5341
    _bz_hypot<int,int> > >
 
5342
hypot(Range d1, int d2)
 
5343
{
 
5344
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
5345
        _bz_hypot<int,int> > T_expr;
 
5346
 
 
5347
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
5348
}
 
5349
 
 
5350
 
 
5351
inline
 
5352
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
5353
    _bz_hypot<int,float> > >
 
5354
hypot(Range d1, float d2)
 
5355
{
 
5356
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
5357
        _bz_hypot<int,float> > T_expr;
 
5358
 
 
5359
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
5360
}
 
5361
 
 
5362
 
 
5363
inline
 
5364
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
5365
    _bz_hypot<int,double> > >
 
5366
hypot(Range d1, double d2)
 
5367
{
 
5368
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
5369
        _bz_hypot<int,double> > T_expr;
 
5370
 
 
5371
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
5372
}
 
5373
 
 
5374
 
 
5375
inline
 
5376
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
5377
    _bz_hypot<int,long double> > >
 
5378
hypot(Range d1, long double d2)
 
5379
{
 
5380
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
5381
        _bz_hypot<int,long double> > T_expr;
 
5382
 
 
5383
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
5384
}
 
5385
 
 
5386
template<class T2>
 
5387
inline
 
5388
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
5389
    _bz_hypot<int,complex<T2> > > >
 
5390
hypot(Range d1, complex<T2> d2)
 
5391
{
 
5392
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
5393
        _bz_hypot<int,complex<T2> > > T_expr;
 
5394
 
 
5395
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
5396
}
 
5397
 
 
5398
template<class P_numtype1, int N_length1, class P_numtype2>
 
5399
inline
 
5400
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
5401
    _bz_hypot<P_numtype1,P_numtype2> > >
 
5402
hypot(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
 
5403
{
 
5404
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
5405
        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
 
5406
 
 
5407
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
5408
}
 
5409
 
 
5410
template<class P_numtype1, int N_length1, class P_expr2>
 
5411
inline
 
5412
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
5413
    _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > >
 
5414
hypot(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
 
5415
{
 
5416
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
5417
        _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
5418
 
 
5419
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
5420
}
 
5421
 
 
5422
template<class P_numtype1, int N_length1, class P_numtype2>
 
5423
inline
 
5424
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
5425
    _bz_hypot<P_numtype1,P_numtype2> > >
 
5426
hypot(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
 
5427
{
 
5428
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
5429
        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
 
5430
 
 
5431
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
5432
}
 
5433
 
 
5434
template<class P_numtype1, int N_length1>
 
5435
inline
 
5436
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
5437
    _bz_hypot<P_numtype1,int> > >
 
5438
hypot(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
 
5439
{
 
5440
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
5441
        _bz_hypot<P_numtype1,int> > T_expr;
 
5442
 
 
5443
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
5444
}
 
5445
 
 
5446
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
 
5447
inline
 
5448
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5449
    _bz_hypot<P_numtype1,P_numtype2> > >
 
5450
hypot(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
5451
{
 
5452
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5453
        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
 
5454
 
 
5455
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
5456
}
 
5457
 
 
5458
template<class P_numtype1, int N_length1>
 
5459
inline
 
5460
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
5461
    _bz_hypot<P_numtype1,int> > >
 
5462
hypot(const TinyVector<P_numtype1, N_length1>& d1, int d2)
 
5463
{
 
5464
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
5465
        _bz_hypot<P_numtype1,int> > T_expr;
 
5466
 
 
5467
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
5468
}
 
5469
 
 
5470
template<class P_numtype1, int N_length1>
 
5471
inline
 
5472
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
5473
    _bz_hypot<P_numtype1,float> > >
 
5474
hypot(const TinyVector<P_numtype1, N_length1>& d1, float d2)
 
5475
{
 
5476
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
5477
        _bz_hypot<P_numtype1,float> > T_expr;
 
5478
 
 
5479
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
5480
}
 
5481
 
 
5482
template<class P_numtype1, int N_length1>
 
5483
inline
 
5484
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
5485
    _bz_hypot<P_numtype1,double> > >
 
5486
hypot(const TinyVector<P_numtype1, N_length1>& d1, double d2)
 
5487
{
 
5488
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
5489
        _bz_hypot<P_numtype1,double> > T_expr;
 
5490
 
 
5491
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
5492
}
 
5493
 
 
5494
template<class P_numtype1, int N_length1>
 
5495
inline
 
5496
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
5497
    _bz_hypot<P_numtype1,long double> > >
 
5498
hypot(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
 
5499
{
 
5500
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
5501
        _bz_hypot<P_numtype1,long double> > T_expr;
 
5502
 
 
5503
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
5504
}
 
5505
 
 
5506
template<class P_numtype1, int N_length1, class T2>
 
5507
inline
 
5508
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
5509
    _bz_hypot<P_numtype1,complex<T2> > > >
 
5510
hypot(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
 
5511
{
 
5512
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
5513
        _bz_hypot<P_numtype1,complex<T2> > > T_expr;
 
5514
 
 
5515
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
5516
}
 
5517
 
 
5518
template<class P_numtype2>
 
5519
inline
 
5520
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
5521
    _bz_hypot<int,P_numtype2> > >
 
5522
hypot(int d1, const Vector<P_numtype2>& d2)
 
5523
{
 
5524
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
5525
        _bz_hypot<int,P_numtype2> > T_expr;
 
5526
 
 
5527
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
5528
}
 
5529
 
 
5530
template<class P_expr2>
 
5531
inline
 
5532
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
5533
    _bz_hypot<int,typename P_expr2::T_numtype> > >
 
5534
hypot(int d1, _bz_VecExpr<P_expr2> d2)
 
5535
{
 
5536
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
5537
        _bz_hypot<int,typename P_expr2::T_numtype> > T_expr;
 
5538
 
 
5539
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
5540
}
 
5541
 
 
5542
template<class P_numtype2>
 
5543
inline
 
5544
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
5545
    _bz_hypot<int,P_numtype2> > >
 
5546
hypot(int d1, const VectorPick<P_numtype2>& d2)
 
5547
{
 
5548
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
5549
        _bz_hypot<int,P_numtype2> > T_expr;
 
5550
 
 
5551
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
5552
}
 
5553
 
 
5554
 
 
5555
inline
 
5556
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
5557
    _bz_hypot<int,int> > >
 
5558
hypot(int d1, Range d2)
 
5559
{
 
5560
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
5561
        _bz_hypot<int,int> > T_expr;
 
5562
 
 
5563
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
5564
}
 
5565
 
 
5566
template<class P_numtype2, int N_length2>
 
5567
inline
 
5568
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5569
    _bz_hypot<int,P_numtype2> > >
 
5570
hypot(int d1, const TinyVector<P_numtype2, N_length2>& d2)
 
5571
{
 
5572
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5573
        _bz_hypot<int,P_numtype2> > T_expr;
 
5574
 
 
5575
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
5576
}
 
5577
 
 
5578
template<class P_numtype2>
 
5579
inline
 
5580
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
5581
    _bz_hypot<float,P_numtype2> > >
 
5582
hypot(float d1, const Vector<P_numtype2>& d2)
 
5583
{
 
5584
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
5585
        _bz_hypot<float,P_numtype2> > T_expr;
 
5586
 
 
5587
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
5588
}
 
5589
 
 
5590
template<class P_expr2>
 
5591
inline
 
5592
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
5593
    _bz_hypot<float,typename P_expr2::T_numtype> > >
 
5594
hypot(float d1, _bz_VecExpr<P_expr2> d2)
 
5595
{
 
5596
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
5597
        _bz_hypot<float,typename P_expr2::T_numtype> > T_expr;
 
5598
 
 
5599
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
5600
}
 
5601
 
 
5602
template<class P_numtype2>
 
5603
inline
 
5604
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
5605
    _bz_hypot<float,P_numtype2> > >
 
5606
hypot(float d1, const VectorPick<P_numtype2>& d2)
 
5607
{
 
5608
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
5609
        _bz_hypot<float,P_numtype2> > T_expr;
 
5610
 
 
5611
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
5612
}
 
5613
 
 
5614
 
 
5615
inline
 
5616
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
5617
    _bz_hypot<float,int> > >
 
5618
hypot(float d1, Range d2)
 
5619
{
 
5620
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
5621
        _bz_hypot<float,int> > T_expr;
 
5622
 
 
5623
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
5624
}
 
5625
 
 
5626
template<class P_numtype2, int N_length2>
 
5627
inline
 
5628
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5629
    _bz_hypot<float,P_numtype2> > >
 
5630
hypot(float d1, const TinyVector<P_numtype2, N_length2>& d2)
 
5631
{
 
5632
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5633
        _bz_hypot<float,P_numtype2> > T_expr;
 
5634
 
 
5635
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
5636
}
 
5637
 
 
5638
template<class P_numtype2>
 
5639
inline
 
5640
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
5641
    _bz_hypot<double,P_numtype2> > >
 
5642
hypot(double d1, const Vector<P_numtype2>& d2)
 
5643
{
 
5644
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
5645
        _bz_hypot<double,P_numtype2> > T_expr;
 
5646
 
 
5647
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
5648
}
 
5649
 
 
5650
template<class P_expr2>
 
5651
inline
 
5652
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
5653
    _bz_hypot<double,typename P_expr2::T_numtype> > >
 
5654
hypot(double d1, _bz_VecExpr<P_expr2> d2)
 
5655
{
 
5656
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
5657
        _bz_hypot<double,typename P_expr2::T_numtype> > T_expr;
 
5658
 
 
5659
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
5660
}
 
5661
 
 
5662
template<class P_numtype2>
 
5663
inline
 
5664
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
5665
    _bz_hypot<double,P_numtype2> > >
 
5666
hypot(double d1, const VectorPick<P_numtype2>& d2)
 
5667
{
 
5668
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
5669
        _bz_hypot<double,P_numtype2> > T_expr;
 
5670
 
 
5671
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
5672
}
 
5673
 
 
5674
 
 
5675
inline
 
5676
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
5677
    _bz_hypot<double,int> > >
 
5678
hypot(double d1, Range d2)
 
5679
{
 
5680
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
5681
        _bz_hypot<double,int> > T_expr;
 
5682
 
 
5683
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
5684
}
 
5685
 
 
5686
template<class P_numtype2, int N_length2>
 
5687
inline
 
5688
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5689
    _bz_hypot<double,P_numtype2> > >
 
5690
hypot(double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
5691
{
 
5692
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5693
        _bz_hypot<double,P_numtype2> > T_expr;
 
5694
 
 
5695
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
5696
}
 
5697
 
 
5698
template<class P_numtype2>
 
5699
inline
 
5700
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
5701
    _bz_hypot<long double,P_numtype2> > >
 
5702
hypot(long double d1, const Vector<P_numtype2>& d2)
 
5703
{
 
5704
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
5705
        _bz_hypot<long double,P_numtype2> > T_expr;
 
5706
 
 
5707
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
5708
}
 
5709
 
 
5710
template<class P_expr2>
 
5711
inline
 
5712
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
5713
    _bz_hypot<long double,typename P_expr2::T_numtype> > >
 
5714
hypot(long double d1, _bz_VecExpr<P_expr2> d2)
 
5715
{
 
5716
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
5717
        _bz_hypot<long double,typename P_expr2::T_numtype> > T_expr;
 
5718
 
 
5719
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
5720
}
 
5721
 
 
5722
template<class P_numtype2>
 
5723
inline
 
5724
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
5725
    _bz_hypot<long double,P_numtype2> > >
 
5726
hypot(long double d1, const VectorPick<P_numtype2>& d2)
 
5727
{
 
5728
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
5729
        _bz_hypot<long double,P_numtype2> > T_expr;
 
5730
 
 
5731
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
5732
}
 
5733
 
 
5734
 
 
5735
inline
 
5736
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
5737
    _bz_hypot<long double,int> > >
 
5738
hypot(long double d1, Range d2)
 
5739
{
 
5740
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
5741
        _bz_hypot<long double,int> > T_expr;
 
5742
 
 
5743
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
5744
}
 
5745
 
 
5746
template<class P_numtype2, int N_length2>
 
5747
inline
 
5748
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5749
    _bz_hypot<long double,P_numtype2> > >
 
5750
hypot(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
5751
{
 
5752
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
5753
        _bz_hypot<long double,P_numtype2> > T_expr;
 
5754
 
 
5755
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
5756
}
 
5757
 
 
5758
template<class T1, class P_numtype2>
 
5759
inline
 
5760
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
5761
    _bz_hypot<complex<T1> ,P_numtype2> > >
 
5762
hypot(complex<T1> d1, const Vector<P_numtype2>& d2)
 
5763
{
 
5764
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
5765
        _bz_hypot<complex<T1> ,P_numtype2> > T_expr;
 
5766
 
 
5767
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
5768
}
 
5769
 
 
5770
template<class T1, class P_expr2>
 
5771
inline
 
5772
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
5773
    _bz_hypot<complex<T1> ,typename P_expr2::T_numtype> > >
 
5774
hypot(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
 
5775
{
 
5776
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
5777
        _bz_hypot<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
 
5778
 
 
5779
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
5780
}
 
5781
 
 
5782
template<class T1, class P_numtype2>
 
5783
inline
 
5784
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
5785
    _bz_hypot<complex<T1> ,P_numtype2> > >
 
5786
hypot(complex<T1> d1, const VectorPick<P_numtype2>& d2)
 
5787
{
 
5788
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
5789
        _bz_hypot<complex<T1> ,P_numtype2> > T_expr;
 
5790
 
 
5791
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
5792
}
 
5793
 
 
5794
template<class T1>
 
5795
inline
 
5796
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
5797
    _bz_hypot<complex<T1> ,int> > >
 
5798
hypot(complex<T1> d1, Range d2)
 
5799
{
 
5800
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
5801
        _bz_hypot<complex<T1> ,int> > T_expr;
 
5802
 
 
5803
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
5804
}
 
5805
 
 
5806
template<class T1, class P_numtype2, int N_length2>
 
5807
inline
 
5808
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
5809
    _bz_hypot<complex<T1> ,P_numtype2> > >
 
5810
hypot(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
5811
{
 
5812
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
5813
        _bz_hypot<complex<T1> ,P_numtype2> > T_expr;
 
5814
 
 
5815
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
5816
}
 
5817
 
 
5818
#endif
 
5819
 
 
5820
/****************************************************************************
 
5821
 * ilogb
 
5822
 ****************************************************************************/
 
5823
 
 
5824
#ifdef BZ_HAVE_IEEE_MATH
 
5825
template<class P_numtype1>
 
5826
inline
 
5827
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
5828
    _bz_ilogb<P_numtype1> > >
 
5829
ilogb(const Vector<P_numtype1>& d1)
 
5830
{
 
5831
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
5832
        _bz_ilogb<P_numtype1> > T_expr;
 
5833
 
 
5834
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
5835
}
 
5836
 
 
5837
template<class P_expr1>
 
5838
inline
 
5839
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
5840
    _bz_ilogb<typename P_expr1::T_numtype> > >
 
5841
ilogb(_bz_VecExpr<P_expr1> d1)
 
5842
{
 
5843
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
5844
        _bz_ilogb<typename P_expr1::T_numtype> > T_expr;
 
5845
 
 
5846
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
5847
}
 
5848
 
 
5849
template<class P_numtype1>
 
5850
inline
 
5851
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
5852
    _bz_ilogb<P_numtype1> > >
 
5853
ilogb(const VectorPick<P_numtype1>& d1)
 
5854
{
 
5855
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
5856
        _bz_ilogb<P_numtype1> > T_expr;
 
5857
 
 
5858
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
5859
}
 
5860
 
 
5861
 
 
5862
inline
 
5863
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
5864
    _bz_ilogb<int> > >
 
5865
ilogb(Range d1)
 
5866
{
 
5867
    typedef _bz_VecExprUnaryOp<Range,
 
5868
        _bz_ilogb<int> > T_expr;
 
5869
 
 
5870
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
5871
}
 
5872
 
 
5873
template<class P_numtype1, int N_length1>
 
5874
inline
 
5875
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
5876
    _bz_ilogb<P_numtype1> > >
 
5877
ilogb(const TinyVector<P_numtype1, N_length1>& d1)
 
5878
{
 
5879
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
5880
        _bz_ilogb<P_numtype1> > T_expr;
 
5881
 
 
5882
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
5883
}
 
5884
 
 
5885
#endif
 
5886
 
 
5887
/****************************************************************************
 
5888
 * blitz_isnan
 
5889
 ****************************************************************************/
 
5890
 
 
5891
#ifdef BZ_HAVE_IEEE_MATH
 
5892
template<class P_numtype1>
 
5893
inline
 
5894
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
5895
    _bz_blitz_isnan<P_numtype1> > >
 
5896
blitz_isnan(const Vector<P_numtype1>& d1)
 
5897
{
 
5898
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
5899
        _bz_blitz_isnan<P_numtype1> > T_expr;
 
5900
 
 
5901
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
5902
}
 
5903
 
 
5904
template<class P_expr1>
 
5905
inline
 
5906
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
5907
    _bz_blitz_isnan<typename P_expr1::T_numtype> > >
 
5908
blitz_isnan(_bz_VecExpr<P_expr1> d1)
 
5909
{
 
5910
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
5911
        _bz_blitz_isnan<typename P_expr1::T_numtype> > T_expr;
 
5912
 
 
5913
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
5914
}
 
5915
 
 
5916
template<class P_numtype1>
 
5917
inline
 
5918
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
5919
    _bz_blitz_isnan<P_numtype1> > >
 
5920
blitz_isnan(const VectorPick<P_numtype1>& d1)
 
5921
{
 
5922
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
5923
        _bz_blitz_isnan<P_numtype1> > T_expr;
 
5924
 
 
5925
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
5926
}
 
5927
 
 
5928
 
 
5929
inline
 
5930
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
5931
    _bz_blitz_isnan<int> > >
 
5932
blitz_isnan(Range d1)
 
5933
{
 
5934
    typedef _bz_VecExprUnaryOp<Range,
 
5935
        _bz_blitz_isnan<int> > T_expr;
 
5936
 
 
5937
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
5938
}
 
5939
 
 
5940
template<class P_numtype1, int N_length1>
 
5941
inline
 
5942
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
5943
    _bz_blitz_isnan<P_numtype1> > >
 
5944
blitz_isnan(const TinyVector<P_numtype1, N_length1>& d1)
 
5945
{
 
5946
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
5947
        _bz_blitz_isnan<P_numtype1> > T_expr;
 
5948
 
 
5949
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
5950
}
 
5951
 
 
5952
#endif
 
5953
 
 
5954
/****************************************************************************
 
5955
 * itrunc
 
5956
 ****************************************************************************/
 
5957
 
 
5958
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
5959
template<class P_numtype1>
 
5960
inline
 
5961
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
5962
    _bz_itrunc<P_numtype1> > >
 
5963
itrunc(const Vector<P_numtype1>& d1)
 
5964
{
 
5965
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
5966
        _bz_itrunc<P_numtype1> > T_expr;
 
5967
 
 
5968
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
5969
}
 
5970
 
 
5971
template<class P_expr1>
 
5972
inline
 
5973
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
5974
    _bz_itrunc<typename P_expr1::T_numtype> > >
 
5975
itrunc(_bz_VecExpr<P_expr1> d1)
 
5976
{
 
5977
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
5978
        _bz_itrunc<typename P_expr1::T_numtype> > T_expr;
 
5979
 
 
5980
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
5981
}
 
5982
 
 
5983
template<class P_numtype1>
 
5984
inline
 
5985
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
5986
    _bz_itrunc<P_numtype1> > >
 
5987
itrunc(const VectorPick<P_numtype1>& d1)
 
5988
{
 
5989
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
5990
        _bz_itrunc<P_numtype1> > T_expr;
 
5991
 
 
5992
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
5993
}
 
5994
 
 
5995
 
 
5996
inline
 
5997
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
5998
    _bz_itrunc<int> > >
 
5999
itrunc(Range d1)
 
6000
{
 
6001
    typedef _bz_VecExprUnaryOp<Range,
 
6002
        _bz_itrunc<int> > T_expr;
 
6003
 
 
6004
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6005
}
 
6006
 
 
6007
template<class P_numtype1, int N_length1>
 
6008
inline
 
6009
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6010
    _bz_itrunc<P_numtype1> > >
 
6011
itrunc(const TinyVector<P_numtype1, N_length1>& d1)
 
6012
{
 
6013
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6014
        _bz_itrunc<P_numtype1> > T_expr;
 
6015
 
 
6016
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6017
}
 
6018
 
 
6019
#endif
 
6020
 
 
6021
/****************************************************************************
 
6022
 * j0
 
6023
 ****************************************************************************/
 
6024
 
 
6025
#ifdef BZ_HAVE_IEEE_MATH
 
6026
template<class P_numtype1>
 
6027
inline
 
6028
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6029
    _bz_j0<P_numtype1> > >
 
6030
j0(const Vector<P_numtype1>& d1)
 
6031
{
 
6032
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6033
        _bz_j0<P_numtype1> > T_expr;
 
6034
 
 
6035
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6036
}
 
6037
 
 
6038
template<class P_expr1>
 
6039
inline
 
6040
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6041
    _bz_j0<typename P_expr1::T_numtype> > >
 
6042
j0(_bz_VecExpr<P_expr1> d1)
 
6043
{
 
6044
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6045
        _bz_j0<typename P_expr1::T_numtype> > T_expr;
 
6046
 
 
6047
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6048
}
 
6049
 
 
6050
template<class P_numtype1>
 
6051
inline
 
6052
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6053
    _bz_j0<P_numtype1> > >
 
6054
j0(const VectorPick<P_numtype1>& d1)
 
6055
{
 
6056
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6057
        _bz_j0<P_numtype1> > T_expr;
 
6058
 
 
6059
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6060
}
 
6061
 
 
6062
 
 
6063
inline
 
6064
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
6065
    _bz_j0<int> > >
 
6066
j0(Range d1)
 
6067
{
 
6068
    typedef _bz_VecExprUnaryOp<Range,
 
6069
        _bz_j0<int> > T_expr;
 
6070
 
 
6071
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6072
}
 
6073
 
 
6074
template<class P_numtype1, int N_length1>
 
6075
inline
 
6076
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6077
    _bz_j0<P_numtype1> > >
 
6078
j0(const TinyVector<P_numtype1, N_length1>& d1)
 
6079
{
 
6080
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6081
        _bz_j0<P_numtype1> > T_expr;
 
6082
 
 
6083
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6084
}
 
6085
 
 
6086
#endif
 
6087
 
 
6088
/****************************************************************************
 
6089
 * j1
 
6090
 ****************************************************************************/
 
6091
 
 
6092
#ifdef BZ_HAVE_IEEE_MATH
 
6093
template<class P_numtype1>
 
6094
inline
 
6095
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6096
    _bz_j1<P_numtype1> > >
 
6097
j1(const Vector<P_numtype1>& d1)
 
6098
{
 
6099
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6100
        _bz_j1<P_numtype1> > T_expr;
 
6101
 
 
6102
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6103
}
 
6104
 
 
6105
template<class P_expr1>
 
6106
inline
 
6107
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6108
    _bz_j1<typename P_expr1::T_numtype> > >
 
6109
j1(_bz_VecExpr<P_expr1> d1)
 
6110
{
 
6111
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6112
        _bz_j1<typename P_expr1::T_numtype> > T_expr;
 
6113
 
 
6114
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6115
}
 
6116
 
 
6117
template<class P_numtype1>
 
6118
inline
 
6119
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6120
    _bz_j1<P_numtype1> > >
 
6121
j1(const VectorPick<P_numtype1>& d1)
 
6122
{
 
6123
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6124
        _bz_j1<P_numtype1> > T_expr;
 
6125
 
 
6126
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6127
}
 
6128
 
 
6129
 
 
6130
inline
 
6131
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
6132
    _bz_j1<int> > >
 
6133
j1(Range d1)
 
6134
{
 
6135
    typedef _bz_VecExprUnaryOp<Range,
 
6136
        _bz_j1<int> > T_expr;
 
6137
 
 
6138
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6139
}
 
6140
 
 
6141
template<class P_numtype1, int N_length1>
 
6142
inline
 
6143
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6144
    _bz_j1<P_numtype1> > >
 
6145
j1(const TinyVector<P_numtype1, N_length1>& d1)
 
6146
{
 
6147
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6148
        _bz_j1<P_numtype1> > T_expr;
 
6149
 
 
6150
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6151
}
 
6152
 
 
6153
#endif
 
6154
 
 
6155
/****************************************************************************
 
6156
 * lgamma
 
6157
 ****************************************************************************/
 
6158
 
 
6159
#ifdef BZ_HAVE_IEEE_MATH
 
6160
template<class P_numtype1>
 
6161
inline
 
6162
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6163
    _bz_lgamma<P_numtype1> > >
 
6164
lgamma(const Vector<P_numtype1>& d1)
 
6165
{
 
6166
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6167
        _bz_lgamma<P_numtype1> > T_expr;
 
6168
 
 
6169
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6170
}
 
6171
 
 
6172
template<class P_expr1>
 
6173
inline
 
6174
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6175
    _bz_lgamma<typename P_expr1::T_numtype> > >
 
6176
lgamma(_bz_VecExpr<P_expr1> d1)
 
6177
{
 
6178
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6179
        _bz_lgamma<typename P_expr1::T_numtype> > T_expr;
 
6180
 
 
6181
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6182
}
 
6183
 
 
6184
template<class P_numtype1>
 
6185
inline
 
6186
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6187
    _bz_lgamma<P_numtype1> > >
 
6188
lgamma(const VectorPick<P_numtype1>& d1)
 
6189
{
 
6190
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6191
        _bz_lgamma<P_numtype1> > T_expr;
 
6192
 
 
6193
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6194
}
 
6195
 
 
6196
 
 
6197
inline
 
6198
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
6199
    _bz_lgamma<int> > >
 
6200
lgamma(Range d1)
 
6201
{
 
6202
    typedef _bz_VecExprUnaryOp<Range,
 
6203
        _bz_lgamma<int> > T_expr;
 
6204
 
 
6205
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6206
}
 
6207
 
 
6208
template<class P_numtype1, int N_length1>
 
6209
inline
 
6210
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6211
    _bz_lgamma<P_numtype1> > >
 
6212
lgamma(const TinyVector<P_numtype1, N_length1>& d1)
 
6213
{
 
6214
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6215
        _bz_lgamma<P_numtype1> > T_expr;
 
6216
 
 
6217
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6218
}
 
6219
 
 
6220
#endif
 
6221
 
 
6222
/****************************************************************************
 
6223
 * log
 
6224
 ****************************************************************************/
 
6225
 
 
6226
template<class P_numtype1>
 
6227
inline
 
6228
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6229
    _bz_log<P_numtype1> > >
 
6230
log(const Vector<P_numtype1>& d1)
 
6231
{
 
6232
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6233
        _bz_log<P_numtype1> > T_expr;
 
6234
 
 
6235
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6236
}
 
6237
 
 
6238
template<class P_expr1>
 
6239
inline
 
6240
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6241
    _bz_log<typename P_expr1::T_numtype> > >
 
6242
log(_bz_VecExpr<P_expr1> d1)
 
6243
{
 
6244
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6245
        _bz_log<typename P_expr1::T_numtype> > T_expr;
 
6246
 
 
6247
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6248
}
 
6249
 
 
6250
template<class P_numtype1>
 
6251
inline
 
6252
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6253
    _bz_log<P_numtype1> > >
 
6254
log(const VectorPick<P_numtype1>& d1)
 
6255
{
 
6256
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6257
        _bz_log<P_numtype1> > T_expr;
 
6258
 
 
6259
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6260
}
 
6261
 
 
6262
 
 
6263
inline
 
6264
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
6265
    _bz_log<int> > >
 
6266
log(Range d1)
 
6267
{
 
6268
    typedef _bz_VecExprUnaryOp<Range,
 
6269
        _bz_log<int> > T_expr;
 
6270
 
 
6271
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6272
}
 
6273
 
 
6274
template<class P_numtype1, int N_length1>
 
6275
inline
 
6276
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6277
    _bz_log<P_numtype1> > >
 
6278
log(const TinyVector<P_numtype1, N_length1>& d1)
 
6279
{
 
6280
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6281
        _bz_log<P_numtype1> > T_expr;
 
6282
 
 
6283
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6284
}
 
6285
 
 
6286
 
 
6287
/****************************************************************************
 
6288
 * logb
 
6289
 ****************************************************************************/
 
6290
 
 
6291
#ifdef BZ_HAVE_IEEE_MATH
 
6292
template<class P_numtype1>
 
6293
inline
 
6294
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6295
    _bz_logb<P_numtype1> > >
 
6296
logb(const Vector<P_numtype1>& d1)
 
6297
{
 
6298
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6299
        _bz_logb<P_numtype1> > T_expr;
 
6300
 
 
6301
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6302
}
 
6303
 
 
6304
template<class P_expr1>
 
6305
inline
 
6306
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6307
    _bz_logb<typename P_expr1::T_numtype> > >
 
6308
logb(_bz_VecExpr<P_expr1> d1)
 
6309
{
 
6310
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6311
        _bz_logb<typename P_expr1::T_numtype> > T_expr;
 
6312
 
 
6313
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6314
}
 
6315
 
 
6316
template<class P_numtype1>
 
6317
inline
 
6318
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6319
    _bz_logb<P_numtype1> > >
 
6320
logb(const VectorPick<P_numtype1>& d1)
 
6321
{
 
6322
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6323
        _bz_logb<P_numtype1> > T_expr;
 
6324
 
 
6325
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6326
}
 
6327
 
 
6328
 
 
6329
inline
 
6330
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
6331
    _bz_logb<int> > >
 
6332
logb(Range d1)
 
6333
{
 
6334
    typedef _bz_VecExprUnaryOp<Range,
 
6335
        _bz_logb<int> > T_expr;
 
6336
 
 
6337
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6338
}
 
6339
 
 
6340
template<class P_numtype1, int N_length1>
 
6341
inline
 
6342
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6343
    _bz_logb<P_numtype1> > >
 
6344
logb(const TinyVector<P_numtype1, N_length1>& d1)
 
6345
{
 
6346
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6347
        _bz_logb<P_numtype1> > T_expr;
 
6348
 
 
6349
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6350
}
 
6351
 
 
6352
#endif
 
6353
 
 
6354
/****************************************************************************
 
6355
 * log1p
 
6356
 ****************************************************************************/
 
6357
 
 
6358
#ifdef BZ_HAVE_IEEE_MATH
 
6359
template<class P_numtype1>
 
6360
inline
 
6361
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6362
    _bz_log1p<P_numtype1> > >
 
6363
log1p(const Vector<P_numtype1>& d1)
 
6364
{
 
6365
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6366
        _bz_log1p<P_numtype1> > T_expr;
 
6367
 
 
6368
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6369
}
 
6370
 
 
6371
template<class P_expr1>
 
6372
inline
 
6373
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6374
    _bz_log1p<typename P_expr1::T_numtype> > >
 
6375
log1p(_bz_VecExpr<P_expr1> d1)
 
6376
{
 
6377
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6378
        _bz_log1p<typename P_expr1::T_numtype> > T_expr;
 
6379
 
 
6380
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6381
}
 
6382
 
 
6383
template<class P_numtype1>
 
6384
inline
 
6385
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6386
    _bz_log1p<P_numtype1> > >
 
6387
log1p(const VectorPick<P_numtype1>& d1)
 
6388
{
 
6389
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6390
        _bz_log1p<P_numtype1> > T_expr;
 
6391
 
 
6392
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6393
}
 
6394
 
 
6395
 
 
6396
inline
 
6397
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
6398
    _bz_log1p<int> > >
 
6399
log1p(Range d1)
 
6400
{
 
6401
    typedef _bz_VecExprUnaryOp<Range,
 
6402
        _bz_log1p<int> > T_expr;
 
6403
 
 
6404
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6405
}
 
6406
 
 
6407
template<class P_numtype1, int N_length1>
 
6408
inline
 
6409
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6410
    _bz_log1p<P_numtype1> > >
 
6411
log1p(const TinyVector<P_numtype1, N_length1>& d1)
 
6412
{
 
6413
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6414
        _bz_log1p<P_numtype1> > T_expr;
 
6415
 
 
6416
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6417
}
 
6418
 
 
6419
#endif
 
6420
 
 
6421
/****************************************************************************
 
6422
 * log10
 
6423
 ****************************************************************************/
 
6424
 
 
6425
template<class P_numtype1>
 
6426
inline
 
6427
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6428
    _bz_log10<P_numtype1> > >
 
6429
log10(const Vector<P_numtype1>& d1)
 
6430
{
 
6431
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6432
        _bz_log10<P_numtype1> > T_expr;
 
6433
 
 
6434
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6435
}
 
6436
 
 
6437
template<class P_expr1>
 
6438
inline
 
6439
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6440
    _bz_log10<typename P_expr1::T_numtype> > >
 
6441
log10(_bz_VecExpr<P_expr1> d1)
 
6442
{
 
6443
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6444
        _bz_log10<typename P_expr1::T_numtype> > T_expr;
 
6445
 
 
6446
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6447
}
 
6448
 
 
6449
template<class P_numtype1>
 
6450
inline
 
6451
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6452
    _bz_log10<P_numtype1> > >
 
6453
log10(const VectorPick<P_numtype1>& d1)
 
6454
{
 
6455
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6456
        _bz_log10<P_numtype1> > T_expr;
 
6457
 
 
6458
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6459
}
 
6460
 
 
6461
 
 
6462
inline
 
6463
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
6464
    _bz_log10<int> > >
 
6465
log10(Range d1)
 
6466
{
 
6467
    typedef _bz_VecExprUnaryOp<Range,
 
6468
        _bz_log10<int> > T_expr;
 
6469
 
 
6470
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6471
}
 
6472
 
 
6473
template<class P_numtype1, int N_length1>
 
6474
inline
 
6475
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6476
    _bz_log10<P_numtype1> > >
 
6477
log10(const TinyVector<P_numtype1, N_length1>& d1)
 
6478
{
 
6479
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6480
        _bz_log10<P_numtype1> > T_expr;
 
6481
 
 
6482
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6483
}
 
6484
 
 
6485
 
 
6486
/****************************************************************************
 
6487
 * nearest
 
6488
 ****************************************************************************/
 
6489
 
 
6490
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
6491
template<class P_numtype1>
 
6492
inline
 
6493
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6494
    _bz_nearest<P_numtype1> > >
 
6495
nearest(const Vector<P_numtype1>& d1)
 
6496
{
 
6497
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
6498
        _bz_nearest<P_numtype1> > T_expr;
 
6499
 
 
6500
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6501
}
 
6502
 
 
6503
template<class P_expr1>
 
6504
inline
 
6505
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6506
    _bz_nearest<typename P_expr1::T_numtype> > >
 
6507
nearest(_bz_VecExpr<P_expr1> d1)
 
6508
{
 
6509
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
6510
        _bz_nearest<typename P_expr1::T_numtype> > T_expr;
 
6511
 
 
6512
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6513
}
 
6514
 
 
6515
template<class P_numtype1>
 
6516
inline
 
6517
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6518
    _bz_nearest<P_numtype1> > >
 
6519
nearest(const VectorPick<P_numtype1>& d1)
 
6520
{
 
6521
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
6522
        _bz_nearest<P_numtype1> > T_expr;
 
6523
 
 
6524
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6525
}
 
6526
 
 
6527
 
 
6528
inline
 
6529
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
6530
    _bz_nearest<int> > >
 
6531
nearest(Range d1)
 
6532
{
 
6533
    typedef _bz_VecExprUnaryOp<Range,
 
6534
        _bz_nearest<int> > T_expr;
 
6535
 
 
6536
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
6537
}
 
6538
 
 
6539
template<class P_numtype1, int N_length1>
 
6540
inline
 
6541
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6542
    _bz_nearest<P_numtype1> > >
 
6543
nearest(const TinyVector<P_numtype1, N_length1>& d1)
 
6544
{
 
6545
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
6546
        _bz_nearest<P_numtype1> > T_expr;
 
6547
 
 
6548
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
6549
}
 
6550
 
 
6551
#endif
 
6552
 
 
6553
/****************************************************************************
 
6554
 * nextafter
 
6555
 ****************************************************************************/
 
6556
 
 
6557
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
6558
template<class P_numtype1, class P_numtype2>
 
6559
inline
 
6560
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
6561
    _bz_nextafter<P_numtype1,P_numtype2> > >
 
6562
nextafter(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
6563
{
 
6564
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
6565
        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
 
6566
 
 
6567
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
6568
}
 
6569
 
 
6570
template<class P_numtype1, class P_expr2>
 
6571
inline
 
6572
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
6573
    _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > >
 
6574
nextafter(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
6575
{
 
6576
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
6577
        _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
6578
 
 
6579
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
6580
}
 
6581
 
 
6582
template<class P_numtype1, class P_numtype2>
 
6583
inline
 
6584
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
6585
    _bz_nextafter<P_numtype1,P_numtype2> > >
 
6586
nextafter(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
6587
{
 
6588
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
6589
        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
 
6590
 
 
6591
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
6592
}
 
6593
 
 
6594
template<class P_numtype1>
 
6595
inline
 
6596
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
6597
    _bz_nextafter<P_numtype1,int> > >
 
6598
nextafter(const Vector<P_numtype1>& d1, Range d2)
 
6599
{
 
6600
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
6601
        _bz_nextafter<P_numtype1,int> > T_expr;
 
6602
 
 
6603
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
6604
}
 
6605
 
 
6606
template<class P_numtype1, class P_numtype2, int N_length2>
 
6607
inline
 
6608
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
6609
    _bz_nextafter<P_numtype1,P_numtype2> > >
 
6610
nextafter(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
6611
{
 
6612
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
6613
        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
 
6614
 
 
6615
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
6616
}
 
6617
 
 
6618
template<class P_numtype1>
 
6619
inline
 
6620
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
6621
    _bz_nextafter<P_numtype1,int> > >
 
6622
nextafter(const Vector<P_numtype1>& d1, int d2)
 
6623
{
 
6624
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
6625
        _bz_nextafter<P_numtype1,int> > T_expr;
 
6626
 
 
6627
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
6628
}
 
6629
 
 
6630
template<class P_numtype1>
 
6631
inline
 
6632
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
6633
    _bz_nextafter<P_numtype1,float> > >
 
6634
nextafter(const Vector<P_numtype1>& d1, float d2)
 
6635
{
 
6636
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
6637
        _bz_nextafter<P_numtype1,float> > T_expr;
 
6638
 
 
6639
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
6640
}
 
6641
 
 
6642
template<class P_numtype1>
 
6643
inline
 
6644
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
6645
    _bz_nextafter<P_numtype1,double> > >
 
6646
nextafter(const Vector<P_numtype1>& d1, double d2)
 
6647
{
 
6648
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
6649
        _bz_nextafter<P_numtype1,double> > T_expr;
 
6650
 
 
6651
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
6652
}
 
6653
 
 
6654
template<class P_numtype1>
 
6655
inline
 
6656
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
6657
    _bz_nextafter<P_numtype1,long double> > >
 
6658
nextafter(const Vector<P_numtype1>& d1, long double d2)
 
6659
{
 
6660
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
6661
        _bz_nextafter<P_numtype1,long double> > T_expr;
 
6662
 
 
6663
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
6664
}
 
6665
 
 
6666
template<class P_numtype1, class T2>
 
6667
inline
 
6668
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
6669
    _bz_nextafter<P_numtype1,complex<T2> > > >
 
6670
nextafter(const Vector<P_numtype1>& d1, complex<T2> d2)
 
6671
{
 
6672
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
6673
        _bz_nextafter<P_numtype1,complex<T2> > > T_expr;
 
6674
 
 
6675
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
6676
}
 
6677
 
 
6678
template<class P_expr1, class P_numtype2>
 
6679
inline
 
6680
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
6681
    _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > >
 
6682
nextafter(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
 
6683
{
 
6684
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
6685
        _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
6686
 
 
6687
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
6688
}
 
6689
 
 
6690
template<class P_expr1, class P_expr2>
 
6691
inline
 
6692
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
6693
    _bz_nextafter<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
 
6694
nextafter(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
 
6695
{
 
6696
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
6697
        _bz_nextafter<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
 
6698
 
 
6699
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
6700
}
 
6701
 
 
6702
template<class P_expr1, class P_numtype2>
 
6703
inline
 
6704
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
6705
    _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > >
 
6706
nextafter(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
 
6707
{
 
6708
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
6709
        _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
6710
 
 
6711
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
6712
}
 
6713
 
 
6714
template<class P_expr1>
 
6715
inline
 
6716
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
6717
    _bz_nextafter<typename P_expr1::T_numtype,int> > >
 
6718
nextafter(_bz_VecExpr<P_expr1> d1, Range d2)
 
6719
{
 
6720
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
6721
        _bz_nextafter<typename P_expr1::T_numtype,int> > T_expr;
 
6722
 
 
6723
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
6724
}
 
6725
 
 
6726
template<class P_expr1, class P_numtype2, int N_length2>
 
6727
inline
 
6728
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
6729
    _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > >
 
6730
nextafter(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
6731
{
 
6732
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
6733
        _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
6734
 
 
6735
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
6736
}
 
6737
 
 
6738
template<class P_expr1>
 
6739
inline
 
6740
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
6741
    _bz_nextafter<typename P_expr1::T_numtype,int> > >
 
6742
nextafter(_bz_VecExpr<P_expr1> d1, int d2)
 
6743
{
 
6744
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
6745
        _bz_nextafter<typename P_expr1::T_numtype,int> > T_expr;
 
6746
 
 
6747
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
6748
}
 
6749
 
 
6750
template<class P_expr1>
 
6751
inline
 
6752
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
6753
    _bz_nextafter<typename P_expr1::T_numtype,float> > >
 
6754
nextafter(_bz_VecExpr<P_expr1> d1, float d2)
 
6755
{
 
6756
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
6757
        _bz_nextafter<typename P_expr1::T_numtype,float> > T_expr;
 
6758
 
 
6759
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
6760
}
 
6761
 
 
6762
template<class P_expr1>
 
6763
inline
 
6764
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
6765
    _bz_nextafter<typename P_expr1::T_numtype,double> > >
 
6766
nextafter(_bz_VecExpr<P_expr1> d1, double d2)
 
6767
{
 
6768
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
6769
        _bz_nextafter<typename P_expr1::T_numtype,double> > T_expr;
 
6770
 
 
6771
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
6772
}
 
6773
 
 
6774
template<class P_expr1>
 
6775
inline
 
6776
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
6777
    _bz_nextafter<typename P_expr1::T_numtype,long double> > >
 
6778
nextafter(_bz_VecExpr<P_expr1> d1, long double d2)
 
6779
{
 
6780
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
6781
        _bz_nextafter<typename P_expr1::T_numtype,long double> > T_expr;
 
6782
 
 
6783
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
6784
}
 
6785
 
 
6786
template<class P_expr1, class T2>
 
6787
inline
 
6788
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
6789
    _bz_nextafter<typename P_expr1::T_numtype,complex<T2> > > >
 
6790
nextafter(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
 
6791
{
 
6792
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
6793
        _bz_nextafter<typename P_expr1::T_numtype,complex<T2> > > T_expr;
 
6794
 
 
6795
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
6796
}
 
6797
 
 
6798
template<class P_numtype1, class P_numtype2>
 
6799
inline
 
6800
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
6801
    _bz_nextafter<P_numtype1,P_numtype2> > >
 
6802
nextafter(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
6803
{
 
6804
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
6805
        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
 
6806
 
 
6807
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
6808
}
 
6809
 
 
6810
template<class P_numtype1, class P_expr2>
 
6811
inline
 
6812
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
6813
    _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > >
 
6814
nextafter(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
6815
{
 
6816
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
6817
        _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
6818
 
 
6819
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
6820
}
 
6821
 
 
6822
template<class P_numtype1, class P_numtype2>
 
6823
inline
 
6824
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
6825
    _bz_nextafter<P_numtype1,P_numtype2> > >
 
6826
nextafter(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
6827
{
 
6828
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
6829
        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
 
6830
 
 
6831
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
6832
}
 
6833
 
 
6834
template<class P_numtype1>
 
6835
inline
 
6836
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
6837
    _bz_nextafter<P_numtype1,int> > >
 
6838
nextafter(const VectorPick<P_numtype1>& d1, Range d2)
 
6839
{
 
6840
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
6841
        _bz_nextafter<P_numtype1,int> > T_expr;
 
6842
 
 
6843
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
6844
}
 
6845
 
 
6846
template<class P_numtype1, class P_numtype2, int N_length2>
 
6847
inline
 
6848
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
6849
    _bz_nextafter<P_numtype1,P_numtype2> > >
 
6850
nextafter(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
6851
{
 
6852
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
6853
        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
 
6854
 
 
6855
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
6856
}
 
6857
 
 
6858
template<class P_numtype1>
 
6859
inline
 
6860
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
6861
    _bz_nextafter<P_numtype1,int> > >
 
6862
nextafter(const VectorPick<P_numtype1>& d1, int d2)
 
6863
{
 
6864
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
6865
        _bz_nextafter<P_numtype1,int> > T_expr;
 
6866
 
 
6867
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
6868
}
 
6869
 
 
6870
template<class P_numtype1>
 
6871
inline
 
6872
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
6873
    _bz_nextafter<P_numtype1,float> > >
 
6874
nextafter(const VectorPick<P_numtype1>& d1, float d2)
 
6875
{
 
6876
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
6877
        _bz_nextafter<P_numtype1,float> > T_expr;
 
6878
 
 
6879
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
6880
}
 
6881
 
 
6882
template<class P_numtype1>
 
6883
inline
 
6884
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
6885
    _bz_nextafter<P_numtype1,double> > >
 
6886
nextafter(const VectorPick<P_numtype1>& d1, double d2)
 
6887
{
 
6888
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
6889
        _bz_nextafter<P_numtype1,double> > T_expr;
 
6890
 
 
6891
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
6892
}
 
6893
 
 
6894
template<class P_numtype1>
 
6895
inline
 
6896
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
6897
    _bz_nextafter<P_numtype1,long double> > >
 
6898
nextafter(const VectorPick<P_numtype1>& d1, long double d2)
 
6899
{
 
6900
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
6901
        _bz_nextafter<P_numtype1,long double> > T_expr;
 
6902
 
 
6903
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
6904
}
 
6905
 
 
6906
template<class P_numtype1, class T2>
 
6907
inline
 
6908
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
6909
    _bz_nextafter<P_numtype1,complex<T2> > > >
 
6910
nextafter(const VectorPick<P_numtype1>& d1, complex<T2> d2)
 
6911
{
 
6912
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
6913
        _bz_nextafter<P_numtype1,complex<T2> > > T_expr;
 
6914
 
 
6915
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
6916
}
 
6917
 
 
6918
template<class P_numtype2>
 
6919
inline
 
6920
_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
6921
    _bz_nextafter<int,P_numtype2> > >
 
6922
nextafter(Range d1, const Vector<P_numtype2>& d2)
 
6923
{
 
6924
    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
6925
        _bz_nextafter<int,P_numtype2> > T_expr;
 
6926
 
 
6927
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
6928
}
 
6929
 
 
6930
template<class P_expr2>
 
6931
inline
 
6932
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
6933
    _bz_nextafter<int,typename P_expr2::T_numtype> > >
 
6934
nextafter(Range d1, _bz_VecExpr<P_expr2> d2)
 
6935
{
 
6936
    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
6937
        _bz_nextafter<int,typename P_expr2::T_numtype> > T_expr;
 
6938
 
 
6939
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
6940
}
 
6941
 
 
6942
template<class P_numtype2>
 
6943
inline
 
6944
_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
6945
    _bz_nextafter<int,P_numtype2> > >
 
6946
nextafter(Range d1, const VectorPick<P_numtype2>& d2)
 
6947
{
 
6948
    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
6949
        _bz_nextafter<int,P_numtype2> > T_expr;
 
6950
 
 
6951
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
6952
}
 
6953
 
 
6954
 
 
6955
inline
 
6956
_bz_VecExpr<_bz_VecExprOp<Range, Range,
 
6957
    _bz_nextafter<int,int> > >
 
6958
nextafter(Range d1, Range d2)
 
6959
{
 
6960
    typedef _bz_VecExprOp<Range, Range,
 
6961
        _bz_nextafter<int,int> > T_expr;
 
6962
 
 
6963
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
6964
}
 
6965
 
 
6966
template<class P_numtype2, int N_length2>
 
6967
inline
 
6968
_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
6969
    _bz_nextafter<int,P_numtype2> > >
 
6970
nextafter(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
 
6971
{
 
6972
    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
6973
        _bz_nextafter<int,P_numtype2> > T_expr;
 
6974
 
 
6975
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
6976
}
 
6977
 
 
6978
 
 
6979
inline
 
6980
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
6981
    _bz_nextafter<int,int> > >
 
6982
nextafter(Range d1, int d2)
 
6983
{
 
6984
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
6985
        _bz_nextafter<int,int> > T_expr;
 
6986
 
 
6987
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
6988
}
 
6989
 
 
6990
 
 
6991
inline
 
6992
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
6993
    _bz_nextafter<int,float> > >
 
6994
nextafter(Range d1, float d2)
 
6995
{
 
6996
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
6997
        _bz_nextafter<int,float> > T_expr;
 
6998
 
 
6999
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
7000
}
 
7001
 
 
7002
 
 
7003
inline
 
7004
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
7005
    _bz_nextafter<int,double> > >
 
7006
nextafter(Range d1, double d2)
 
7007
{
 
7008
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
7009
        _bz_nextafter<int,double> > T_expr;
 
7010
 
 
7011
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
7012
}
 
7013
 
 
7014
 
 
7015
inline
 
7016
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
7017
    _bz_nextafter<int,long double> > >
 
7018
nextafter(Range d1, long double d2)
 
7019
{
 
7020
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
7021
        _bz_nextafter<int,long double> > T_expr;
 
7022
 
 
7023
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
7024
}
 
7025
 
 
7026
template<class T2>
 
7027
inline
 
7028
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
7029
    _bz_nextafter<int,complex<T2> > > >
 
7030
nextafter(Range d1, complex<T2> d2)
 
7031
{
 
7032
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
7033
        _bz_nextafter<int,complex<T2> > > T_expr;
 
7034
 
 
7035
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
7036
}
 
7037
 
 
7038
template<class P_numtype1, int N_length1, class P_numtype2>
 
7039
inline
 
7040
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
7041
    _bz_nextafter<P_numtype1,P_numtype2> > >
 
7042
nextafter(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
 
7043
{
 
7044
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
7045
        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
 
7046
 
 
7047
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7048
}
 
7049
 
 
7050
template<class P_numtype1, int N_length1, class P_expr2>
 
7051
inline
 
7052
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
7053
    _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > >
 
7054
nextafter(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
 
7055
{
 
7056
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
7057
        _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
7058
 
 
7059
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
7060
}
 
7061
 
 
7062
template<class P_numtype1, int N_length1, class P_numtype2>
 
7063
inline
 
7064
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
7065
    _bz_nextafter<P_numtype1,P_numtype2> > >
 
7066
nextafter(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
 
7067
{
 
7068
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
7069
        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
 
7070
 
 
7071
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7072
}
 
7073
 
 
7074
template<class P_numtype1, int N_length1>
 
7075
inline
 
7076
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
7077
    _bz_nextafter<P_numtype1,int> > >
 
7078
nextafter(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
 
7079
{
 
7080
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
7081
        _bz_nextafter<P_numtype1,int> > T_expr;
 
7082
 
 
7083
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
7084
}
 
7085
 
 
7086
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
 
7087
inline
 
7088
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7089
    _bz_nextafter<P_numtype1,P_numtype2> > >
 
7090
nextafter(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7091
{
 
7092
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7093
        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
 
7094
 
 
7095
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7096
}
 
7097
 
 
7098
template<class P_numtype1, int N_length1>
 
7099
inline
 
7100
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
7101
    _bz_nextafter<P_numtype1,int> > >
 
7102
nextafter(const TinyVector<P_numtype1, N_length1>& d1, int d2)
 
7103
{
 
7104
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
7105
        _bz_nextafter<P_numtype1,int> > T_expr;
 
7106
 
 
7107
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
7108
}
 
7109
 
 
7110
template<class P_numtype1, int N_length1>
 
7111
inline
 
7112
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
7113
    _bz_nextafter<P_numtype1,float> > >
 
7114
nextafter(const TinyVector<P_numtype1, N_length1>& d1, float d2)
 
7115
{
 
7116
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
7117
        _bz_nextafter<P_numtype1,float> > T_expr;
 
7118
 
 
7119
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
7120
}
 
7121
 
 
7122
template<class P_numtype1, int N_length1>
 
7123
inline
 
7124
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
7125
    _bz_nextafter<P_numtype1,double> > >
 
7126
nextafter(const TinyVector<P_numtype1, N_length1>& d1, double d2)
 
7127
{
 
7128
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
7129
        _bz_nextafter<P_numtype1,double> > T_expr;
 
7130
 
 
7131
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
7132
}
 
7133
 
 
7134
template<class P_numtype1, int N_length1>
 
7135
inline
 
7136
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
7137
    _bz_nextafter<P_numtype1,long double> > >
 
7138
nextafter(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
 
7139
{
 
7140
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
7141
        _bz_nextafter<P_numtype1,long double> > T_expr;
 
7142
 
 
7143
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
7144
}
 
7145
 
 
7146
template<class P_numtype1, int N_length1, class T2>
 
7147
inline
 
7148
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
7149
    _bz_nextafter<P_numtype1,complex<T2> > > >
 
7150
nextafter(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
 
7151
{
 
7152
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
7153
        _bz_nextafter<P_numtype1,complex<T2> > > T_expr;
 
7154
 
 
7155
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
7156
}
 
7157
 
 
7158
template<class P_numtype2>
 
7159
inline
 
7160
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
7161
    _bz_nextafter<int,P_numtype2> > >
 
7162
nextafter(int d1, const Vector<P_numtype2>& d2)
 
7163
{
 
7164
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
7165
        _bz_nextafter<int,P_numtype2> > T_expr;
 
7166
 
 
7167
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
7168
}
 
7169
 
 
7170
template<class P_expr2>
 
7171
inline
 
7172
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
7173
    _bz_nextafter<int,typename P_expr2::T_numtype> > >
 
7174
nextafter(int d1, _bz_VecExpr<P_expr2> d2)
 
7175
{
 
7176
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
7177
        _bz_nextafter<int,typename P_expr2::T_numtype> > T_expr;
 
7178
 
 
7179
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
7180
}
 
7181
 
 
7182
template<class P_numtype2>
 
7183
inline
 
7184
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
7185
    _bz_nextafter<int,P_numtype2> > >
 
7186
nextafter(int d1, const VectorPick<P_numtype2>& d2)
 
7187
{
 
7188
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
7189
        _bz_nextafter<int,P_numtype2> > T_expr;
 
7190
 
 
7191
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
7192
}
 
7193
 
 
7194
 
 
7195
inline
 
7196
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
7197
    _bz_nextafter<int,int> > >
 
7198
nextafter(int d1, Range d2)
 
7199
{
 
7200
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
7201
        _bz_nextafter<int,int> > T_expr;
 
7202
 
 
7203
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
7204
}
 
7205
 
 
7206
template<class P_numtype2, int N_length2>
 
7207
inline
 
7208
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7209
    _bz_nextafter<int,P_numtype2> > >
 
7210
nextafter(int d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7211
{
 
7212
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7213
        _bz_nextafter<int,P_numtype2> > T_expr;
 
7214
 
 
7215
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
7216
}
 
7217
 
 
7218
template<class P_numtype2>
 
7219
inline
 
7220
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
7221
    _bz_nextafter<float,P_numtype2> > >
 
7222
nextafter(float d1, const Vector<P_numtype2>& d2)
 
7223
{
 
7224
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
7225
        _bz_nextafter<float,P_numtype2> > T_expr;
 
7226
 
 
7227
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
7228
}
 
7229
 
 
7230
template<class P_expr2>
 
7231
inline
 
7232
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
7233
    _bz_nextafter<float,typename P_expr2::T_numtype> > >
 
7234
nextafter(float d1, _bz_VecExpr<P_expr2> d2)
 
7235
{
 
7236
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
7237
        _bz_nextafter<float,typename P_expr2::T_numtype> > T_expr;
 
7238
 
 
7239
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
7240
}
 
7241
 
 
7242
template<class P_numtype2>
 
7243
inline
 
7244
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
7245
    _bz_nextafter<float,P_numtype2> > >
 
7246
nextafter(float d1, const VectorPick<P_numtype2>& d2)
 
7247
{
 
7248
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
7249
        _bz_nextafter<float,P_numtype2> > T_expr;
 
7250
 
 
7251
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
7252
}
 
7253
 
 
7254
 
 
7255
inline
 
7256
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
7257
    _bz_nextafter<float,int> > >
 
7258
nextafter(float d1, Range d2)
 
7259
{
 
7260
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
7261
        _bz_nextafter<float,int> > T_expr;
 
7262
 
 
7263
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
7264
}
 
7265
 
 
7266
template<class P_numtype2, int N_length2>
 
7267
inline
 
7268
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7269
    _bz_nextafter<float,P_numtype2> > >
 
7270
nextafter(float d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7271
{
 
7272
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7273
        _bz_nextafter<float,P_numtype2> > T_expr;
 
7274
 
 
7275
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
7276
}
 
7277
 
 
7278
template<class P_numtype2>
 
7279
inline
 
7280
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
7281
    _bz_nextafter<double,P_numtype2> > >
 
7282
nextafter(double d1, const Vector<P_numtype2>& d2)
 
7283
{
 
7284
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
7285
        _bz_nextafter<double,P_numtype2> > T_expr;
 
7286
 
 
7287
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
7288
}
 
7289
 
 
7290
template<class P_expr2>
 
7291
inline
 
7292
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
7293
    _bz_nextafter<double,typename P_expr2::T_numtype> > >
 
7294
nextafter(double d1, _bz_VecExpr<P_expr2> d2)
 
7295
{
 
7296
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
7297
        _bz_nextafter<double,typename P_expr2::T_numtype> > T_expr;
 
7298
 
 
7299
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
7300
}
 
7301
 
 
7302
template<class P_numtype2>
 
7303
inline
 
7304
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
7305
    _bz_nextafter<double,P_numtype2> > >
 
7306
nextafter(double d1, const VectorPick<P_numtype2>& d2)
 
7307
{
 
7308
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
7309
        _bz_nextafter<double,P_numtype2> > T_expr;
 
7310
 
 
7311
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
7312
}
 
7313
 
 
7314
 
 
7315
inline
 
7316
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
7317
    _bz_nextafter<double,int> > >
 
7318
nextafter(double d1, Range d2)
 
7319
{
 
7320
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
7321
        _bz_nextafter<double,int> > T_expr;
 
7322
 
 
7323
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
7324
}
 
7325
 
 
7326
template<class P_numtype2, int N_length2>
 
7327
inline
 
7328
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7329
    _bz_nextafter<double,P_numtype2> > >
 
7330
nextafter(double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7331
{
 
7332
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7333
        _bz_nextafter<double,P_numtype2> > T_expr;
 
7334
 
 
7335
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
7336
}
 
7337
 
 
7338
template<class P_numtype2>
 
7339
inline
 
7340
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
7341
    _bz_nextafter<long double,P_numtype2> > >
 
7342
nextafter(long double d1, const Vector<P_numtype2>& d2)
 
7343
{
 
7344
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
7345
        _bz_nextafter<long double,P_numtype2> > T_expr;
 
7346
 
 
7347
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
7348
}
 
7349
 
 
7350
template<class P_expr2>
 
7351
inline
 
7352
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
7353
    _bz_nextafter<long double,typename P_expr2::T_numtype> > >
 
7354
nextafter(long double d1, _bz_VecExpr<P_expr2> d2)
 
7355
{
 
7356
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
7357
        _bz_nextafter<long double,typename P_expr2::T_numtype> > T_expr;
 
7358
 
 
7359
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
7360
}
 
7361
 
 
7362
template<class P_numtype2>
 
7363
inline
 
7364
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
7365
    _bz_nextafter<long double,P_numtype2> > >
 
7366
nextafter(long double d1, const VectorPick<P_numtype2>& d2)
 
7367
{
 
7368
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
7369
        _bz_nextafter<long double,P_numtype2> > T_expr;
 
7370
 
 
7371
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
7372
}
 
7373
 
 
7374
 
 
7375
inline
 
7376
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
7377
    _bz_nextafter<long double,int> > >
 
7378
nextafter(long double d1, Range d2)
 
7379
{
 
7380
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
7381
        _bz_nextafter<long double,int> > T_expr;
 
7382
 
 
7383
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
7384
}
 
7385
 
 
7386
template<class P_numtype2, int N_length2>
 
7387
inline
 
7388
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7389
    _bz_nextafter<long double,P_numtype2> > >
 
7390
nextafter(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7391
{
 
7392
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7393
        _bz_nextafter<long double,P_numtype2> > T_expr;
 
7394
 
 
7395
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
7396
}
 
7397
 
 
7398
template<class T1, class P_numtype2>
 
7399
inline
 
7400
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
7401
    _bz_nextafter<complex<T1> ,P_numtype2> > >
 
7402
nextafter(complex<T1> d1, const Vector<P_numtype2>& d2)
 
7403
{
 
7404
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
7405
        _bz_nextafter<complex<T1> ,P_numtype2> > T_expr;
 
7406
 
 
7407
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
7408
}
 
7409
 
 
7410
template<class T1, class P_expr2>
 
7411
inline
 
7412
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
7413
    _bz_nextafter<complex<T1> ,typename P_expr2::T_numtype> > >
 
7414
nextafter(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
 
7415
{
 
7416
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
7417
        _bz_nextafter<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
 
7418
 
 
7419
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
7420
}
 
7421
 
 
7422
template<class T1, class P_numtype2>
 
7423
inline
 
7424
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
7425
    _bz_nextafter<complex<T1> ,P_numtype2> > >
 
7426
nextafter(complex<T1> d1, const VectorPick<P_numtype2>& d2)
 
7427
{
 
7428
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
7429
        _bz_nextafter<complex<T1> ,P_numtype2> > T_expr;
 
7430
 
 
7431
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
7432
}
 
7433
 
 
7434
template<class T1>
 
7435
inline
 
7436
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
7437
    _bz_nextafter<complex<T1> ,int> > >
 
7438
nextafter(complex<T1> d1, Range d2)
 
7439
{
 
7440
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
7441
        _bz_nextafter<complex<T1> ,int> > T_expr;
 
7442
 
 
7443
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
7444
}
 
7445
 
 
7446
template<class T1, class P_numtype2, int N_length2>
 
7447
inline
 
7448
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
7449
    _bz_nextafter<complex<T1> ,P_numtype2> > >
 
7450
nextafter(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7451
{
 
7452
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
7453
        _bz_nextafter<complex<T1> ,P_numtype2> > T_expr;
 
7454
 
 
7455
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
7456
}
 
7457
 
 
7458
#endif
 
7459
 
 
7460
/****************************************************************************
 
7461
 * pow
 
7462
 ****************************************************************************/
 
7463
 
 
7464
template<class P_numtype1, class P_numtype2>
 
7465
inline
 
7466
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
7467
    _bz_pow<P_numtype1,P_numtype2> > >
 
7468
pow(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
7469
{
 
7470
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
7471
        _bz_pow<P_numtype1,P_numtype2> > T_expr;
 
7472
 
 
7473
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7474
}
 
7475
 
 
7476
template<class P_numtype1, class P_expr2>
 
7477
inline
 
7478
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
7479
    _bz_pow<P_numtype1,typename P_expr2::T_numtype> > >
 
7480
pow(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
7481
{
 
7482
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
7483
        _bz_pow<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
7484
 
 
7485
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
7486
}
 
7487
 
 
7488
template<class P_numtype1, class P_numtype2>
 
7489
inline
 
7490
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
7491
    _bz_pow<P_numtype1,P_numtype2> > >
 
7492
pow(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
7493
{
 
7494
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
7495
        _bz_pow<P_numtype1,P_numtype2> > T_expr;
 
7496
 
 
7497
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7498
}
 
7499
 
 
7500
template<class P_numtype1>
 
7501
inline
 
7502
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
7503
    _bz_pow<P_numtype1,int> > >
 
7504
pow(const Vector<P_numtype1>& d1, Range d2)
 
7505
{
 
7506
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
7507
        _bz_pow<P_numtype1,int> > T_expr;
 
7508
 
 
7509
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
7510
}
 
7511
 
 
7512
template<class P_numtype1, class P_numtype2, int N_length2>
 
7513
inline
 
7514
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7515
    _bz_pow<P_numtype1,P_numtype2> > >
 
7516
pow(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7517
{
 
7518
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7519
        _bz_pow<P_numtype1,P_numtype2> > T_expr;
 
7520
 
 
7521
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7522
}
 
7523
 
 
7524
template<class P_numtype1>
 
7525
inline
 
7526
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
7527
    _bz_pow<P_numtype1,int> > >
 
7528
pow(const Vector<P_numtype1>& d1, int d2)
 
7529
{
 
7530
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
7531
        _bz_pow<P_numtype1,int> > T_expr;
 
7532
 
 
7533
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
7534
}
 
7535
 
 
7536
template<class P_numtype1>
 
7537
inline
 
7538
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
7539
    _bz_pow<P_numtype1,float> > >
 
7540
pow(const Vector<P_numtype1>& d1, float d2)
 
7541
{
 
7542
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
7543
        _bz_pow<P_numtype1,float> > T_expr;
 
7544
 
 
7545
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
7546
}
 
7547
 
 
7548
template<class P_numtype1>
 
7549
inline
 
7550
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
7551
    _bz_pow<P_numtype1,double> > >
 
7552
pow(const Vector<P_numtype1>& d1, double d2)
 
7553
{
 
7554
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
7555
        _bz_pow<P_numtype1,double> > T_expr;
 
7556
 
 
7557
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
7558
}
 
7559
 
 
7560
template<class P_numtype1>
 
7561
inline
 
7562
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
7563
    _bz_pow<P_numtype1,long double> > >
 
7564
pow(const Vector<P_numtype1>& d1, long double d2)
 
7565
{
 
7566
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
7567
        _bz_pow<P_numtype1,long double> > T_expr;
 
7568
 
 
7569
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
7570
}
 
7571
 
 
7572
template<class P_numtype1, class T2>
 
7573
inline
 
7574
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
7575
    _bz_pow<P_numtype1,complex<T2> > > >
 
7576
pow(const Vector<P_numtype1>& d1, complex<T2> d2)
 
7577
{
 
7578
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
7579
        _bz_pow<P_numtype1,complex<T2> > > T_expr;
 
7580
 
 
7581
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
7582
}
 
7583
 
 
7584
template<class P_expr1, class P_numtype2>
 
7585
inline
 
7586
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
7587
    _bz_pow<typename P_expr1::T_numtype,P_numtype2> > >
 
7588
pow(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
 
7589
{
 
7590
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
7591
        _bz_pow<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
7592
 
 
7593
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
7594
}
 
7595
 
 
7596
template<class P_expr1, class P_expr2>
 
7597
inline
 
7598
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
7599
    _bz_pow<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
 
7600
pow(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
 
7601
{
 
7602
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
7603
        _bz_pow<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
 
7604
 
 
7605
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
7606
}
 
7607
 
 
7608
template<class P_expr1, class P_numtype2>
 
7609
inline
 
7610
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
7611
    _bz_pow<typename P_expr1::T_numtype,P_numtype2> > >
 
7612
pow(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
 
7613
{
 
7614
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
7615
        _bz_pow<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
7616
 
 
7617
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
7618
}
 
7619
 
 
7620
template<class P_expr1>
 
7621
inline
 
7622
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
7623
    _bz_pow<typename P_expr1::T_numtype,int> > >
 
7624
pow(_bz_VecExpr<P_expr1> d1, Range d2)
 
7625
{
 
7626
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
7627
        _bz_pow<typename P_expr1::T_numtype,int> > T_expr;
 
7628
 
 
7629
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
7630
}
 
7631
 
 
7632
template<class P_expr1, class P_numtype2, int N_length2>
 
7633
inline
 
7634
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7635
    _bz_pow<typename P_expr1::T_numtype,P_numtype2> > >
 
7636
pow(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7637
{
 
7638
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7639
        _bz_pow<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
7640
 
 
7641
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
7642
}
 
7643
 
 
7644
template<class P_expr1>
 
7645
inline
 
7646
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
7647
    _bz_pow<typename P_expr1::T_numtype,int> > >
 
7648
pow(_bz_VecExpr<P_expr1> d1, int d2)
 
7649
{
 
7650
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
7651
        _bz_pow<typename P_expr1::T_numtype,int> > T_expr;
 
7652
 
 
7653
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
7654
}
 
7655
 
 
7656
template<class P_expr1>
 
7657
inline
 
7658
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
7659
    _bz_pow<typename P_expr1::T_numtype,float> > >
 
7660
pow(_bz_VecExpr<P_expr1> d1, float d2)
 
7661
{
 
7662
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
7663
        _bz_pow<typename P_expr1::T_numtype,float> > T_expr;
 
7664
 
 
7665
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
7666
}
 
7667
 
 
7668
template<class P_expr1>
 
7669
inline
 
7670
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
7671
    _bz_pow<typename P_expr1::T_numtype,double> > >
 
7672
pow(_bz_VecExpr<P_expr1> d1, double d2)
 
7673
{
 
7674
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
7675
        _bz_pow<typename P_expr1::T_numtype,double> > T_expr;
 
7676
 
 
7677
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
7678
}
 
7679
 
 
7680
template<class P_expr1>
 
7681
inline
 
7682
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
7683
    _bz_pow<typename P_expr1::T_numtype,long double> > >
 
7684
pow(_bz_VecExpr<P_expr1> d1, long double d2)
 
7685
{
 
7686
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
7687
        _bz_pow<typename P_expr1::T_numtype,long double> > T_expr;
 
7688
 
 
7689
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
7690
}
 
7691
 
 
7692
template<class P_expr1, class T2>
 
7693
inline
 
7694
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
7695
    _bz_pow<typename P_expr1::T_numtype,complex<T2> > > >
 
7696
pow(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
 
7697
{
 
7698
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
7699
        _bz_pow<typename P_expr1::T_numtype,complex<T2> > > T_expr;
 
7700
 
 
7701
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
7702
}
 
7703
 
 
7704
template<class P_numtype1, class P_numtype2>
 
7705
inline
 
7706
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
7707
    _bz_pow<P_numtype1,P_numtype2> > >
 
7708
pow(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
7709
{
 
7710
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
7711
        _bz_pow<P_numtype1,P_numtype2> > T_expr;
 
7712
 
 
7713
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7714
}
 
7715
 
 
7716
template<class P_numtype1, class P_expr2>
 
7717
inline
 
7718
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
7719
    _bz_pow<P_numtype1,typename P_expr2::T_numtype> > >
 
7720
pow(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
7721
{
 
7722
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
7723
        _bz_pow<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
7724
 
 
7725
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
7726
}
 
7727
 
 
7728
template<class P_numtype1, class P_numtype2>
 
7729
inline
 
7730
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
7731
    _bz_pow<P_numtype1,P_numtype2> > >
 
7732
pow(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
7733
{
 
7734
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
7735
        _bz_pow<P_numtype1,P_numtype2> > T_expr;
 
7736
 
 
7737
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7738
}
 
7739
 
 
7740
template<class P_numtype1>
 
7741
inline
 
7742
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
7743
    _bz_pow<P_numtype1,int> > >
 
7744
pow(const VectorPick<P_numtype1>& d1, Range d2)
 
7745
{
 
7746
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
7747
        _bz_pow<P_numtype1,int> > T_expr;
 
7748
 
 
7749
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
7750
}
 
7751
 
 
7752
template<class P_numtype1, class P_numtype2, int N_length2>
 
7753
inline
 
7754
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7755
    _bz_pow<P_numtype1,P_numtype2> > >
 
7756
pow(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7757
{
 
7758
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7759
        _bz_pow<P_numtype1,P_numtype2> > T_expr;
 
7760
 
 
7761
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7762
}
 
7763
 
 
7764
template<class P_numtype1>
 
7765
inline
 
7766
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
7767
    _bz_pow<P_numtype1,int> > >
 
7768
pow(const VectorPick<P_numtype1>& d1, int d2)
 
7769
{
 
7770
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
7771
        _bz_pow<P_numtype1,int> > T_expr;
 
7772
 
 
7773
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
7774
}
 
7775
 
 
7776
template<class P_numtype1>
 
7777
inline
 
7778
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
7779
    _bz_pow<P_numtype1,float> > >
 
7780
pow(const VectorPick<P_numtype1>& d1, float d2)
 
7781
{
 
7782
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
7783
        _bz_pow<P_numtype1,float> > T_expr;
 
7784
 
 
7785
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
7786
}
 
7787
 
 
7788
template<class P_numtype1>
 
7789
inline
 
7790
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
7791
    _bz_pow<P_numtype1,double> > >
 
7792
pow(const VectorPick<P_numtype1>& d1, double d2)
 
7793
{
 
7794
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
7795
        _bz_pow<P_numtype1,double> > T_expr;
 
7796
 
 
7797
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
7798
}
 
7799
 
 
7800
template<class P_numtype1>
 
7801
inline
 
7802
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
7803
    _bz_pow<P_numtype1,long double> > >
 
7804
pow(const VectorPick<P_numtype1>& d1, long double d2)
 
7805
{
 
7806
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
7807
        _bz_pow<P_numtype1,long double> > T_expr;
 
7808
 
 
7809
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
7810
}
 
7811
 
 
7812
template<class P_numtype1, class T2>
 
7813
inline
 
7814
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
7815
    _bz_pow<P_numtype1,complex<T2> > > >
 
7816
pow(const VectorPick<P_numtype1>& d1, complex<T2> d2)
 
7817
{
 
7818
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
7819
        _bz_pow<P_numtype1,complex<T2> > > T_expr;
 
7820
 
 
7821
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
7822
}
 
7823
 
 
7824
template<class P_numtype2>
 
7825
inline
 
7826
_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
7827
    _bz_pow<int,P_numtype2> > >
 
7828
pow(Range d1, const Vector<P_numtype2>& d2)
 
7829
{
 
7830
    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
7831
        _bz_pow<int,P_numtype2> > T_expr;
 
7832
 
 
7833
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
7834
}
 
7835
 
 
7836
template<class P_expr2>
 
7837
inline
 
7838
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
7839
    _bz_pow<int,typename P_expr2::T_numtype> > >
 
7840
pow(Range d1, _bz_VecExpr<P_expr2> d2)
 
7841
{
 
7842
    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
7843
        _bz_pow<int,typename P_expr2::T_numtype> > T_expr;
 
7844
 
 
7845
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
7846
}
 
7847
 
 
7848
template<class P_numtype2>
 
7849
inline
 
7850
_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
7851
    _bz_pow<int,P_numtype2> > >
 
7852
pow(Range d1, const VectorPick<P_numtype2>& d2)
 
7853
{
 
7854
    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
7855
        _bz_pow<int,P_numtype2> > T_expr;
 
7856
 
 
7857
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
7858
}
 
7859
 
 
7860
 
 
7861
inline
 
7862
_bz_VecExpr<_bz_VecExprOp<Range, Range,
 
7863
    _bz_pow<int,int> > >
 
7864
pow(Range d1, Range d2)
 
7865
{
 
7866
    typedef _bz_VecExprOp<Range, Range,
 
7867
        _bz_pow<int,int> > T_expr;
 
7868
 
 
7869
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
7870
}
 
7871
 
 
7872
template<class P_numtype2, int N_length2>
 
7873
inline
 
7874
_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
7875
    _bz_pow<int,P_numtype2> > >
 
7876
pow(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7877
{
 
7878
    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
7879
        _bz_pow<int,P_numtype2> > T_expr;
 
7880
 
 
7881
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
7882
}
 
7883
 
 
7884
 
 
7885
inline
 
7886
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
7887
    _bz_pow<int,int> > >
 
7888
pow(Range d1, int d2)
 
7889
{
 
7890
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
7891
        _bz_pow<int,int> > T_expr;
 
7892
 
 
7893
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
7894
}
 
7895
 
 
7896
 
 
7897
inline
 
7898
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
7899
    _bz_pow<int,float> > >
 
7900
pow(Range d1, float d2)
 
7901
{
 
7902
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
7903
        _bz_pow<int,float> > T_expr;
 
7904
 
 
7905
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
7906
}
 
7907
 
 
7908
 
 
7909
inline
 
7910
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
7911
    _bz_pow<int,double> > >
 
7912
pow(Range d1, double d2)
 
7913
{
 
7914
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
7915
        _bz_pow<int,double> > T_expr;
 
7916
 
 
7917
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
7918
}
 
7919
 
 
7920
 
 
7921
inline
 
7922
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
7923
    _bz_pow<int,long double> > >
 
7924
pow(Range d1, long double d2)
 
7925
{
 
7926
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
7927
        _bz_pow<int,long double> > T_expr;
 
7928
 
 
7929
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
7930
}
 
7931
 
 
7932
template<class T2>
 
7933
inline
 
7934
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
7935
    _bz_pow<int,complex<T2> > > >
 
7936
pow(Range d1, complex<T2> d2)
 
7937
{
 
7938
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
7939
        _bz_pow<int,complex<T2> > > T_expr;
 
7940
 
 
7941
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
7942
}
 
7943
 
 
7944
template<class P_numtype1, int N_length1, class P_numtype2>
 
7945
inline
 
7946
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
7947
    _bz_pow<P_numtype1,P_numtype2> > >
 
7948
pow(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
 
7949
{
 
7950
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
7951
        _bz_pow<P_numtype1,P_numtype2> > T_expr;
 
7952
 
 
7953
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7954
}
 
7955
 
 
7956
template<class P_numtype1, int N_length1, class P_expr2>
 
7957
inline
 
7958
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
7959
    _bz_pow<P_numtype1,typename P_expr2::T_numtype> > >
 
7960
pow(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
 
7961
{
 
7962
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
7963
        _bz_pow<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
7964
 
 
7965
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
7966
}
 
7967
 
 
7968
template<class P_numtype1, int N_length1, class P_numtype2>
 
7969
inline
 
7970
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
7971
    _bz_pow<P_numtype1,P_numtype2> > >
 
7972
pow(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
 
7973
{
 
7974
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
7975
        _bz_pow<P_numtype1,P_numtype2> > T_expr;
 
7976
 
 
7977
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
7978
}
 
7979
 
 
7980
template<class P_numtype1, int N_length1>
 
7981
inline
 
7982
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
7983
    _bz_pow<P_numtype1,int> > >
 
7984
pow(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
 
7985
{
 
7986
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
7987
        _bz_pow<P_numtype1,int> > T_expr;
 
7988
 
 
7989
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
7990
}
 
7991
 
 
7992
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
 
7993
inline
 
7994
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7995
    _bz_pow<P_numtype1,P_numtype2> > >
 
7996
pow(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
7997
{
 
7998
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
7999
        _bz_pow<P_numtype1,P_numtype2> > T_expr;
 
8000
 
 
8001
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
8002
}
 
8003
 
 
8004
template<class P_numtype1, int N_length1>
 
8005
inline
 
8006
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
8007
    _bz_pow<P_numtype1,int> > >
 
8008
pow(const TinyVector<P_numtype1, N_length1>& d1, int d2)
 
8009
{
 
8010
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
8011
        _bz_pow<P_numtype1,int> > T_expr;
 
8012
 
 
8013
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
8014
}
 
8015
 
 
8016
template<class P_numtype1, int N_length1>
 
8017
inline
 
8018
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
8019
    _bz_pow<P_numtype1,float> > >
 
8020
pow(const TinyVector<P_numtype1, N_length1>& d1, float d2)
 
8021
{
 
8022
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
8023
        _bz_pow<P_numtype1,float> > T_expr;
 
8024
 
 
8025
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
8026
}
 
8027
 
 
8028
template<class P_numtype1, int N_length1>
 
8029
inline
 
8030
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
8031
    _bz_pow<P_numtype1,double> > >
 
8032
pow(const TinyVector<P_numtype1, N_length1>& d1, double d2)
 
8033
{
 
8034
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
8035
        _bz_pow<P_numtype1,double> > T_expr;
 
8036
 
 
8037
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
8038
}
 
8039
 
 
8040
template<class P_numtype1, int N_length1>
 
8041
inline
 
8042
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
8043
    _bz_pow<P_numtype1,long double> > >
 
8044
pow(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
 
8045
{
 
8046
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
8047
        _bz_pow<P_numtype1,long double> > T_expr;
 
8048
 
 
8049
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
8050
}
 
8051
 
 
8052
template<class P_numtype1, int N_length1, class T2>
 
8053
inline
 
8054
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
8055
    _bz_pow<P_numtype1,complex<T2> > > >
 
8056
pow(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
 
8057
{
 
8058
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
8059
        _bz_pow<P_numtype1,complex<T2> > > T_expr;
 
8060
 
 
8061
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
8062
}
 
8063
 
 
8064
template<class P_numtype2>
 
8065
inline
 
8066
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
8067
    _bz_pow<int,P_numtype2> > >
 
8068
pow(int d1, const Vector<P_numtype2>& d2)
 
8069
{
 
8070
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
8071
        _bz_pow<int,P_numtype2> > T_expr;
 
8072
 
 
8073
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
8074
}
 
8075
 
 
8076
template<class P_expr2>
 
8077
inline
 
8078
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
8079
    _bz_pow<int,typename P_expr2::T_numtype> > >
 
8080
pow(int d1, _bz_VecExpr<P_expr2> d2)
 
8081
{
 
8082
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
8083
        _bz_pow<int,typename P_expr2::T_numtype> > T_expr;
 
8084
 
 
8085
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
8086
}
 
8087
 
 
8088
template<class P_numtype2>
 
8089
inline
 
8090
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
8091
    _bz_pow<int,P_numtype2> > >
 
8092
pow(int d1, const VectorPick<P_numtype2>& d2)
 
8093
{
 
8094
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
8095
        _bz_pow<int,P_numtype2> > T_expr;
 
8096
 
 
8097
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
8098
}
 
8099
 
 
8100
 
 
8101
inline
 
8102
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
8103
    _bz_pow<int,int> > >
 
8104
pow(int d1, Range d2)
 
8105
{
 
8106
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
8107
        _bz_pow<int,int> > T_expr;
 
8108
 
 
8109
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
8110
}
 
8111
 
 
8112
template<class P_numtype2, int N_length2>
 
8113
inline
 
8114
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8115
    _bz_pow<int,P_numtype2> > >
 
8116
pow(int d1, const TinyVector<P_numtype2, N_length2>& d2)
 
8117
{
 
8118
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8119
        _bz_pow<int,P_numtype2> > T_expr;
 
8120
 
 
8121
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
8122
}
 
8123
 
 
8124
template<class P_numtype2>
 
8125
inline
 
8126
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
8127
    _bz_pow<float,P_numtype2> > >
 
8128
pow(float d1, const Vector<P_numtype2>& d2)
 
8129
{
 
8130
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
8131
        _bz_pow<float,P_numtype2> > T_expr;
 
8132
 
 
8133
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
8134
}
 
8135
 
 
8136
template<class P_expr2>
 
8137
inline
 
8138
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
8139
    _bz_pow<float,typename P_expr2::T_numtype> > >
 
8140
pow(float d1, _bz_VecExpr<P_expr2> d2)
 
8141
{
 
8142
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
8143
        _bz_pow<float,typename P_expr2::T_numtype> > T_expr;
 
8144
 
 
8145
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
8146
}
 
8147
 
 
8148
template<class P_numtype2>
 
8149
inline
 
8150
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
8151
    _bz_pow<float,P_numtype2> > >
 
8152
pow(float d1, const VectorPick<P_numtype2>& d2)
 
8153
{
 
8154
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
8155
        _bz_pow<float,P_numtype2> > T_expr;
 
8156
 
 
8157
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
8158
}
 
8159
 
 
8160
 
 
8161
inline
 
8162
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
8163
    _bz_pow<float,int> > >
 
8164
pow(float d1, Range d2)
 
8165
{
 
8166
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
8167
        _bz_pow<float,int> > T_expr;
 
8168
 
 
8169
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
8170
}
 
8171
 
 
8172
template<class P_numtype2, int N_length2>
 
8173
inline
 
8174
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8175
    _bz_pow<float,P_numtype2> > >
 
8176
pow(float d1, const TinyVector<P_numtype2, N_length2>& d2)
 
8177
{
 
8178
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8179
        _bz_pow<float,P_numtype2> > T_expr;
 
8180
 
 
8181
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
8182
}
 
8183
 
 
8184
template<class P_numtype2>
 
8185
inline
 
8186
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
8187
    _bz_pow<double,P_numtype2> > >
 
8188
pow(double d1, const Vector<P_numtype2>& d2)
 
8189
{
 
8190
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
8191
        _bz_pow<double,P_numtype2> > T_expr;
 
8192
 
 
8193
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
8194
}
 
8195
 
 
8196
template<class P_expr2>
 
8197
inline
 
8198
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
8199
    _bz_pow<double,typename P_expr2::T_numtype> > >
 
8200
pow(double d1, _bz_VecExpr<P_expr2> d2)
 
8201
{
 
8202
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
8203
        _bz_pow<double,typename P_expr2::T_numtype> > T_expr;
 
8204
 
 
8205
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
8206
}
 
8207
 
 
8208
template<class P_numtype2>
 
8209
inline
 
8210
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
8211
    _bz_pow<double,P_numtype2> > >
 
8212
pow(double d1, const VectorPick<P_numtype2>& d2)
 
8213
{
 
8214
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
8215
        _bz_pow<double,P_numtype2> > T_expr;
 
8216
 
 
8217
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
8218
}
 
8219
 
 
8220
 
 
8221
inline
 
8222
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
8223
    _bz_pow<double,int> > >
 
8224
pow(double d1, Range d2)
 
8225
{
 
8226
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
8227
        _bz_pow<double,int> > T_expr;
 
8228
 
 
8229
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
8230
}
 
8231
 
 
8232
template<class P_numtype2, int N_length2>
 
8233
inline
 
8234
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8235
    _bz_pow<double,P_numtype2> > >
 
8236
pow(double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
8237
{
 
8238
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8239
        _bz_pow<double,P_numtype2> > T_expr;
 
8240
 
 
8241
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
8242
}
 
8243
 
 
8244
template<class P_numtype2>
 
8245
inline
 
8246
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
8247
    _bz_pow<long double,P_numtype2> > >
 
8248
pow(long double d1, const Vector<P_numtype2>& d2)
 
8249
{
 
8250
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
8251
        _bz_pow<long double,P_numtype2> > T_expr;
 
8252
 
 
8253
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
8254
}
 
8255
 
 
8256
template<class P_expr2>
 
8257
inline
 
8258
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
8259
    _bz_pow<long double,typename P_expr2::T_numtype> > >
 
8260
pow(long double d1, _bz_VecExpr<P_expr2> d2)
 
8261
{
 
8262
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
8263
        _bz_pow<long double,typename P_expr2::T_numtype> > T_expr;
 
8264
 
 
8265
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
8266
}
 
8267
 
 
8268
template<class P_numtype2>
 
8269
inline
 
8270
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
8271
    _bz_pow<long double,P_numtype2> > >
 
8272
pow(long double d1, const VectorPick<P_numtype2>& d2)
 
8273
{
 
8274
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
8275
        _bz_pow<long double,P_numtype2> > T_expr;
 
8276
 
 
8277
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
8278
}
 
8279
 
 
8280
 
 
8281
inline
 
8282
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
8283
    _bz_pow<long double,int> > >
 
8284
pow(long double d1, Range d2)
 
8285
{
 
8286
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
8287
        _bz_pow<long double,int> > T_expr;
 
8288
 
 
8289
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
8290
}
 
8291
 
 
8292
template<class P_numtype2, int N_length2>
 
8293
inline
 
8294
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8295
    _bz_pow<long double,P_numtype2> > >
 
8296
pow(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
8297
{
 
8298
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8299
        _bz_pow<long double,P_numtype2> > T_expr;
 
8300
 
 
8301
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
8302
}
 
8303
 
 
8304
template<class T1, class P_numtype2>
 
8305
inline
 
8306
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
8307
    _bz_pow<complex<T1> ,P_numtype2> > >
 
8308
pow(complex<T1> d1, const Vector<P_numtype2>& d2)
 
8309
{
 
8310
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
8311
        _bz_pow<complex<T1> ,P_numtype2> > T_expr;
 
8312
 
 
8313
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
8314
}
 
8315
 
 
8316
template<class T1, class P_expr2>
 
8317
inline
 
8318
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
8319
    _bz_pow<complex<T1> ,typename P_expr2::T_numtype> > >
 
8320
pow(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
 
8321
{
 
8322
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
8323
        _bz_pow<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
 
8324
 
 
8325
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
8326
}
 
8327
 
 
8328
template<class T1, class P_numtype2>
 
8329
inline
 
8330
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
8331
    _bz_pow<complex<T1> ,P_numtype2> > >
 
8332
pow(complex<T1> d1, const VectorPick<P_numtype2>& d2)
 
8333
{
 
8334
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
8335
        _bz_pow<complex<T1> ,P_numtype2> > T_expr;
 
8336
 
 
8337
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
8338
}
 
8339
 
 
8340
template<class T1>
 
8341
inline
 
8342
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
8343
    _bz_pow<complex<T1> ,int> > >
 
8344
pow(complex<T1> d1, Range d2)
 
8345
{
 
8346
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
8347
        _bz_pow<complex<T1> ,int> > T_expr;
 
8348
 
 
8349
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
8350
}
 
8351
 
 
8352
template<class T1, class P_numtype2, int N_length2>
 
8353
inline
 
8354
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
8355
    _bz_pow<complex<T1> ,P_numtype2> > >
 
8356
pow(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
8357
{
 
8358
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
8359
        _bz_pow<complex<T1> ,P_numtype2> > T_expr;
 
8360
 
 
8361
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
8362
}
 
8363
 
 
8364
 
 
8365
/****************************************************************************
 
8366
 * remainder
 
8367
 ****************************************************************************/
 
8368
 
 
8369
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
8370
template<class P_numtype1, class P_numtype2>
 
8371
inline
 
8372
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
8373
    _bz_remainder<P_numtype1,P_numtype2> > >
 
8374
remainder(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
8375
{
 
8376
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
8377
        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
 
8378
 
 
8379
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
8380
}
 
8381
 
 
8382
template<class P_numtype1, class P_expr2>
 
8383
inline
 
8384
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
8385
    _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > >
 
8386
remainder(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
8387
{
 
8388
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
8389
        _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
8390
 
 
8391
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
8392
}
 
8393
 
 
8394
template<class P_numtype1, class P_numtype2>
 
8395
inline
 
8396
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
8397
    _bz_remainder<P_numtype1,P_numtype2> > >
 
8398
remainder(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
8399
{
 
8400
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
8401
        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
 
8402
 
 
8403
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
8404
}
 
8405
 
 
8406
template<class P_numtype1>
 
8407
inline
 
8408
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
8409
    _bz_remainder<P_numtype1,int> > >
 
8410
remainder(const Vector<P_numtype1>& d1, Range d2)
 
8411
{
 
8412
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
8413
        _bz_remainder<P_numtype1,int> > T_expr;
 
8414
 
 
8415
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
8416
}
 
8417
 
 
8418
template<class P_numtype1, class P_numtype2, int N_length2>
 
8419
inline
 
8420
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8421
    _bz_remainder<P_numtype1,P_numtype2> > >
 
8422
remainder(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
8423
{
 
8424
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8425
        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
 
8426
 
 
8427
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
8428
}
 
8429
 
 
8430
template<class P_numtype1>
 
8431
inline
 
8432
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
8433
    _bz_remainder<P_numtype1,int> > >
 
8434
remainder(const Vector<P_numtype1>& d1, int d2)
 
8435
{
 
8436
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
8437
        _bz_remainder<P_numtype1,int> > T_expr;
 
8438
 
 
8439
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
8440
}
 
8441
 
 
8442
template<class P_numtype1>
 
8443
inline
 
8444
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
8445
    _bz_remainder<P_numtype1,float> > >
 
8446
remainder(const Vector<P_numtype1>& d1, float d2)
 
8447
{
 
8448
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
8449
        _bz_remainder<P_numtype1,float> > T_expr;
 
8450
 
 
8451
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
8452
}
 
8453
 
 
8454
template<class P_numtype1>
 
8455
inline
 
8456
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
8457
    _bz_remainder<P_numtype1,double> > >
 
8458
remainder(const Vector<P_numtype1>& d1, double d2)
 
8459
{
 
8460
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
8461
        _bz_remainder<P_numtype1,double> > T_expr;
 
8462
 
 
8463
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
8464
}
 
8465
 
 
8466
template<class P_numtype1>
 
8467
inline
 
8468
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
8469
    _bz_remainder<P_numtype1,long double> > >
 
8470
remainder(const Vector<P_numtype1>& d1, long double d2)
 
8471
{
 
8472
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
8473
        _bz_remainder<P_numtype1,long double> > T_expr;
 
8474
 
 
8475
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
8476
}
 
8477
 
 
8478
template<class P_numtype1, class T2>
 
8479
inline
 
8480
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
8481
    _bz_remainder<P_numtype1,complex<T2> > > >
 
8482
remainder(const Vector<P_numtype1>& d1, complex<T2> d2)
 
8483
{
 
8484
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
8485
        _bz_remainder<P_numtype1,complex<T2> > > T_expr;
 
8486
 
 
8487
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
8488
}
 
8489
 
 
8490
template<class P_expr1, class P_numtype2>
 
8491
inline
 
8492
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
8493
    _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > >
 
8494
remainder(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
 
8495
{
 
8496
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
8497
        _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
8498
 
 
8499
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
8500
}
 
8501
 
 
8502
template<class P_expr1, class P_expr2>
 
8503
inline
 
8504
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
8505
    _bz_remainder<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
 
8506
remainder(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
 
8507
{
 
8508
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
8509
        _bz_remainder<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
 
8510
 
 
8511
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
8512
}
 
8513
 
 
8514
template<class P_expr1, class P_numtype2>
 
8515
inline
 
8516
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
8517
    _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > >
 
8518
remainder(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
 
8519
{
 
8520
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
8521
        _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
8522
 
 
8523
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
8524
}
 
8525
 
 
8526
template<class P_expr1>
 
8527
inline
 
8528
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
8529
    _bz_remainder<typename P_expr1::T_numtype,int> > >
 
8530
remainder(_bz_VecExpr<P_expr1> d1, Range d2)
 
8531
{
 
8532
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
8533
        _bz_remainder<typename P_expr1::T_numtype,int> > T_expr;
 
8534
 
 
8535
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
8536
}
 
8537
 
 
8538
template<class P_expr1, class P_numtype2, int N_length2>
 
8539
inline
 
8540
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8541
    _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > >
 
8542
remainder(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
8543
{
 
8544
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8545
        _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
8546
 
 
8547
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
8548
}
 
8549
 
 
8550
template<class P_expr1>
 
8551
inline
 
8552
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
8553
    _bz_remainder<typename P_expr1::T_numtype,int> > >
 
8554
remainder(_bz_VecExpr<P_expr1> d1, int d2)
 
8555
{
 
8556
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
8557
        _bz_remainder<typename P_expr1::T_numtype,int> > T_expr;
 
8558
 
 
8559
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
8560
}
 
8561
 
 
8562
template<class P_expr1>
 
8563
inline
 
8564
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
8565
    _bz_remainder<typename P_expr1::T_numtype,float> > >
 
8566
remainder(_bz_VecExpr<P_expr1> d1, float d2)
 
8567
{
 
8568
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
8569
        _bz_remainder<typename P_expr1::T_numtype,float> > T_expr;
 
8570
 
 
8571
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
8572
}
 
8573
 
 
8574
template<class P_expr1>
 
8575
inline
 
8576
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
8577
    _bz_remainder<typename P_expr1::T_numtype,double> > >
 
8578
remainder(_bz_VecExpr<P_expr1> d1, double d2)
 
8579
{
 
8580
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
8581
        _bz_remainder<typename P_expr1::T_numtype,double> > T_expr;
 
8582
 
 
8583
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
8584
}
 
8585
 
 
8586
template<class P_expr1>
 
8587
inline
 
8588
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
8589
    _bz_remainder<typename P_expr1::T_numtype,long double> > >
 
8590
remainder(_bz_VecExpr<P_expr1> d1, long double d2)
 
8591
{
 
8592
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
8593
        _bz_remainder<typename P_expr1::T_numtype,long double> > T_expr;
 
8594
 
 
8595
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
8596
}
 
8597
 
 
8598
template<class P_expr1, class T2>
 
8599
inline
 
8600
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
8601
    _bz_remainder<typename P_expr1::T_numtype,complex<T2> > > >
 
8602
remainder(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
 
8603
{
 
8604
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
8605
        _bz_remainder<typename P_expr1::T_numtype,complex<T2> > > T_expr;
 
8606
 
 
8607
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
8608
}
 
8609
 
 
8610
template<class P_numtype1, class P_numtype2>
 
8611
inline
 
8612
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
8613
    _bz_remainder<P_numtype1,P_numtype2> > >
 
8614
remainder(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
8615
{
 
8616
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
8617
        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
 
8618
 
 
8619
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
8620
}
 
8621
 
 
8622
template<class P_numtype1, class P_expr2>
 
8623
inline
 
8624
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
8625
    _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > >
 
8626
remainder(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
8627
{
 
8628
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
8629
        _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
8630
 
 
8631
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
8632
}
 
8633
 
 
8634
template<class P_numtype1, class P_numtype2>
 
8635
inline
 
8636
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
8637
    _bz_remainder<P_numtype1,P_numtype2> > >
 
8638
remainder(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
8639
{
 
8640
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
8641
        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
 
8642
 
 
8643
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
8644
}
 
8645
 
 
8646
template<class P_numtype1>
 
8647
inline
 
8648
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
8649
    _bz_remainder<P_numtype1,int> > >
 
8650
remainder(const VectorPick<P_numtype1>& d1, Range d2)
 
8651
{
 
8652
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
8653
        _bz_remainder<P_numtype1,int> > T_expr;
 
8654
 
 
8655
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
8656
}
 
8657
 
 
8658
template<class P_numtype1, class P_numtype2, int N_length2>
 
8659
inline
 
8660
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8661
    _bz_remainder<P_numtype1,P_numtype2> > >
 
8662
remainder(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
8663
{
 
8664
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8665
        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
 
8666
 
 
8667
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
8668
}
 
8669
 
 
8670
template<class P_numtype1>
 
8671
inline
 
8672
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
8673
    _bz_remainder<P_numtype1,int> > >
 
8674
remainder(const VectorPick<P_numtype1>& d1, int d2)
 
8675
{
 
8676
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
8677
        _bz_remainder<P_numtype1,int> > T_expr;
 
8678
 
 
8679
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
8680
}
 
8681
 
 
8682
template<class P_numtype1>
 
8683
inline
 
8684
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
8685
    _bz_remainder<P_numtype1,float> > >
 
8686
remainder(const VectorPick<P_numtype1>& d1, float d2)
 
8687
{
 
8688
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
8689
        _bz_remainder<P_numtype1,float> > T_expr;
 
8690
 
 
8691
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
8692
}
 
8693
 
 
8694
template<class P_numtype1>
 
8695
inline
 
8696
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
8697
    _bz_remainder<P_numtype1,double> > >
 
8698
remainder(const VectorPick<P_numtype1>& d1, double d2)
 
8699
{
 
8700
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
8701
        _bz_remainder<P_numtype1,double> > T_expr;
 
8702
 
 
8703
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
8704
}
 
8705
 
 
8706
template<class P_numtype1>
 
8707
inline
 
8708
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
8709
    _bz_remainder<P_numtype1,long double> > >
 
8710
remainder(const VectorPick<P_numtype1>& d1, long double d2)
 
8711
{
 
8712
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
8713
        _bz_remainder<P_numtype1,long double> > T_expr;
 
8714
 
 
8715
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
8716
}
 
8717
 
 
8718
template<class P_numtype1, class T2>
 
8719
inline
 
8720
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
8721
    _bz_remainder<P_numtype1,complex<T2> > > >
 
8722
remainder(const VectorPick<P_numtype1>& d1, complex<T2> d2)
 
8723
{
 
8724
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
8725
        _bz_remainder<P_numtype1,complex<T2> > > T_expr;
 
8726
 
 
8727
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
8728
}
 
8729
 
 
8730
template<class P_numtype2>
 
8731
inline
 
8732
_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
8733
    _bz_remainder<int,P_numtype2> > >
 
8734
remainder(Range d1, const Vector<P_numtype2>& d2)
 
8735
{
 
8736
    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
8737
        _bz_remainder<int,P_numtype2> > T_expr;
 
8738
 
 
8739
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
8740
}
 
8741
 
 
8742
template<class P_expr2>
 
8743
inline
 
8744
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
8745
    _bz_remainder<int,typename P_expr2::T_numtype> > >
 
8746
remainder(Range d1, _bz_VecExpr<P_expr2> d2)
 
8747
{
 
8748
    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
8749
        _bz_remainder<int,typename P_expr2::T_numtype> > T_expr;
 
8750
 
 
8751
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
8752
}
 
8753
 
 
8754
template<class P_numtype2>
 
8755
inline
 
8756
_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
8757
    _bz_remainder<int,P_numtype2> > >
 
8758
remainder(Range d1, const VectorPick<P_numtype2>& d2)
 
8759
{
 
8760
    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
8761
        _bz_remainder<int,P_numtype2> > T_expr;
 
8762
 
 
8763
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
8764
}
 
8765
 
 
8766
 
 
8767
inline
 
8768
_bz_VecExpr<_bz_VecExprOp<Range, Range,
 
8769
    _bz_remainder<int,int> > >
 
8770
remainder(Range d1, Range d2)
 
8771
{
 
8772
    typedef _bz_VecExprOp<Range, Range,
 
8773
        _bz_remainder<int,int> > T_expr;
 
8774
 
 
8775
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
8776
}
 
8777
 
 
8778
template<class P_numtype2, int N_length2>
 
8779
inline
 
8780
_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
8781
    _bz_remainder<int,P_numtype2> > >
 
8782
remainder(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
 
8783
{
 
8784
    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
8785
        _bz_remainder<int,P_numtype2> > T_expr;
 
8786
 
 
8787
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
8788
}
 
8789
 
 
8790
 
 
8791
inline
 
8792
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
8793
    _bz_remainder<int,int> > >
 
8794
remainder(Range d1, int d2)
 
8795
{
 
8796
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
8797
        _bz_remainder<int,int> > T_expr;
 
8798
 
 
8799
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
8800
}
 
8801
 
 
8802
 
 
8803
inline
 
8804
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
8805
    _bz_remainder<int,float> > >
 
8806
remainder(Range d1, float d2)
 
8807
{
 
8808
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
8809
        _bz_remainder<int,float> > T_expr;
 
8810
 
 
8811
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
8812
}
 
8813
 
 
8814
 
 
8815
inline
 
8816
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
8817
    _bz_remainder<int,double> > >
 
8818
remainder(Range d1, double d2)
 
8819
{
 
8820
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
8821
        _bz_remainder<int,double> > T_expr;
 
8822
 
 
8823
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
8824
}
 
8825
 
 
8826
 
 
8827
inline
 
8828
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
8829
    _bz_remainder<int,long double> > >
 
8830
remainder(Range d1, long double d2)
 
8831
{
 
8832
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
8833
        _bz_remainder<int,long double> > T_expr;
 
8834
 
 
8835
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
8836
}
 
8837
 
 
8838
template<class T2>
 
8839
inline
 
8840
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
8841
    _bz_remainder<int,complex<T2> > > >
 
8842
remainder(Range d1, complex<T2> d2)
 
8843
{
 
8844
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
8845
        _bz_remainder<int,complex<T2> > > T_expr;
 
8846
 
 
8847
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
8848
}
 
8849
 
 
8850
template<class P_numtype1, int N_length1, class P_numtype2>
 
8851
inline
 
8852
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
8853
    _bz_remainder<P_numtype1,P_numtype2> > >
 
8854
remainder(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
 
8855
{
 
8856
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
8857
        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
 
8858
 
 
8859
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
8860
}
 
8861
 
 
8862
template<class P_numtype1, int N_length1, class P_expr2>
 
8863
inline
 
8864
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
8865
    _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > >
 
8866
remainder(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
 
8867
{
 
8868
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
8869
        _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
8870
 
 
8871
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
8872
}
 
8873
 
 
8874
template<class P_numtype1, int N_length1, class P_numtype2>
 
8875
inline
 
8876
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
8877
    _bz_remainder<P_numtype1,P_numtype2> > >
 
8878
remainder(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
 
8879
{
 
8880
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
8881
        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
 
8882
 
 
8883
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
8884
}
 
8885
 
 
8886
template<class P_numtype1, int N_length1>
 
8887
inline
 
8888
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
8889
    _bz_remainder<P_numtype1,int> > >
 
8890
remainder(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
 
8891
{
 
8892
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
8893
        _bz_remainder<P_numtype1,int> > T_expr;
 
8894
 
 
8895
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
8896
}
 
8897
 
 
8898
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
 
8899
inline
 
8900
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8901
    _bz_remainder<P_numtype1,P_numtype2> > >
 
8902
remainder(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
8903
{
 
8904
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
8905
        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
 
8906
 
 
8907
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
8908
}
 
8909
 
 
8910
template<class P_numtype1, int N_length1>
 
8911
inline
 
8912
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
8913
    _bz_remainder<P_numtype1,int> > >
 
8914
remainder(const TinyVector<P_numtype1, N_length1>& d1, int d2)
 
8915
{
 
8916
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
8917
        _bz_remainder<P_numtype1,int> > T_expr;
 
8918
 
 
8919
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
8920
}
 
8921
 
 
8922
template<class P_numtype1, int N_length1>
 
8923
inline
 
8924
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
8925
    _bz_remainder<P_numtype1,float> > >
 
8926
remainder(const TinyVector<P_numtype1, N_length1>& d1, float d2)
 
8927
{
 
8928
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
8929
        _bz_remainder<P_numtype1,float> > T_expr;
 
8930
 
 
8931
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
8932
}
 
8933
 
 
8934
template<class P_numtype1, int N_length1>
 
8935
inline
 
8936
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
8937
    _bz_remainder<P_numtype1,double> > >
 
8938
remainder(const TinyVector<P_numtype1, N_length1>& d1, double d2)
 
8939
{
 
8940
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
8941
        _bz_remainder<P_numtype1,double> > T_expr;
 
8942
 
 
8943
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
8944
}
 
8945
 
 
8946
template<class P_numtype1, int N_length1>
 
8947
inline
 
8948
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
8949
    _bz_remainder<P_numtype1,long double> > >
 
8950
remainder(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
 
8951
{
 
8952
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
8953
        _bz_remainder<P_numtype1,long double> > T_expr;
 
8954
 
 
8955
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
8956
}
 
8957
 
 
8958
template<class P_numtype1, int N_length1, class T2>
 
8959
inline
 
8960
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
8961
    _bz_remainder<P_numtype1,complex<T2> > > >
 
8962
remainder(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
 
8963
{
 
8964
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
8965
        _bz_remainder<P_numtype1,complex<T2> > > T_expr;
 
8966
 
 
8967
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
8968
}
 
8969
 
 
8970
template<class P_numtype2>
 
8971
inline
 
8972
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
8973
    _bz_remainder<int,P_numtype2> > >
 
8974
remainder(int d1, const Vector<P_numtype2>& d2)
 
8975
{
 
8976
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
8977
        _bz_remainder<int,P_numtype2> > T_expr;
 
8978
 
 
8979
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
8980
}
 
8981
 
 
8982
template<class P_expr2>
 
8983
inline
 
8984
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
8985
    _bz_remainder<int,typename P_expr2::T_numtype> > >
 
8986
remainder(int d1, _bz_VecExpr<P_expr2> d2)
 
8987
{
 
8988
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
8989
        _bz_remainder<int,typename P_expr2::T_numtype> > T_expr;
 
8990
 
 
8991
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
8992
}
 
8993
 
 
8994
template<class P_numtype2>
 
8995
inline
 
8996
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
8997
    _bz_remainder<int,P_numtype2> > >
 
8998
remainder(int d1, const VectorPick<P_numtype2>& d2)
 
8999
{
 
9000
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
9001
        _bz_remainder<int,P_numtype2> > T_expr;
 
9002
 
 
9003
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
9004
}
 
9005
 
 
9006
 
 
9007
inline
 
9008
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
9009
    _bz_remainder<int,int> > >
 
9010
remainder(int d1, Range d2)
 
9011
{
 
9012
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
9013
        _bz_remainder<int,int> > T_expr;
 
9014
 
 
9015
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
9016
}
 
9017
 
 
9018
template<class P_numtype2, int N_length2>
 
9019
inline
 
9020
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9021
    _bz_remainder<int,P_numtype2> > >
 
9022
remainder(int d1, const TinyVector<P_numtype2, N_length2>& d2)
 
9023
{
 
9024
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9025
        _bz_remainder<int,P_numtype2> > T_expr;
 
9026
 
 
9027
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
9028
}
 
9029
 
 
9030
template<class P_numtype2>
 
9031
inline
 
9032
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
9033
    _bz_remainder<float,P_numtype2> > >
 
9034
remainder(float d1, const Vector<P_numtype2>& d2)
 
9035
{
 
9036
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
9037
        _bz_remainder<float,P_numtype2> > T_expr;
 
9038
 
 
9039
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
9040
}
 
9041
 
 
9042
template<class P_expr2>
 
9043
inline
 
9044
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
9045
    _bz_remainder<float,typename P_expr2::T_numtype> > >
 
9046
remainder(float d1, _bz_VecExpr<P_expr2> d2)
 
9047
{
 
9048
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
9049
        _bz_remainder<float,typename P_expr2::T_numtype> > T_expr;
 
9050
 
 
9051
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
9052
}
 
9053
 
 
9054
template<class P_numtype2>
 
9055
inline
 
9056
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
9057
    _bz_remainder<float,P_numtype2> > >
 
9058
remainder(float d1, const VectorPick<P_numtype2>& d2)
 
9059
{
 
9060
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
9061
        _bz_remainder<float,P_numtype2> > T_expr;
 
9062
 
 
9063
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
9064
}
 
9065
 
 
9066
 
 
9067
inline
 
9068
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
9069
    _bz_remainder<float,int> > >
 
9070
remainder(float d1, Range d2)
 
9071
{
 
9072
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
9073
        _bz_remainder<float,int> > T_expr;
 
9074
 
 
9075
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
9076
}
 
9077
 
 
9078
template<class P_numtype2, int N_length2>
 
9079
inline
 
9080
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9081
    _bz_remainder<float,P_numtype2> > >
 
9082
remainder(float d1, const TinyVector<P_numtype2, N_length2>& d2)
 
9083
{
 
9084
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9085
        _bz_remainder<float,P_numtype2> > T_expr;
 
9086
 
 
9087
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
9088
}
 
9089
 
 
9090
template<class P_numtype2>
 
9091
inline
 
9092
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
9093
    _bz_remainder<double,P_numtype2> > >
 
9094
remainder(double d1, const Vector<P_numtype2>& d2)
 
9095
{
 
9096
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
9097
        _bz_remainder<double,P_numtype2> > T_expr;
 
9098
 
 
9099
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
9100
}
 
9101
 
 
9102
template<class P_expr2>
 
9103
inline
 
9104
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
9105
    _bz_remainder<double,typename P_expr2::T_numtype> > >
 
9106
remainder(double d1, _bz_VecExpr<P_expr2> d2)
 
9107
{
 
9108
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
9109
        _bz_remainder<double,typename P_expr2::T_numtype> > T_expr;
 
9110
 
 
9111
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
9112
}
 
9113
 
 
9114
template<class P_numtype2>
 
9115
inline
 
9116
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
9117
    _bz_remainder<double,P_numtype2> > >
 
9118
remainder(double d1, const VectorPick<P_numtype2>& d2)
 
9119
{
 
9120
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
9121
        _bz_remainder<double,P_numtype2> > T_expr;
 
9122
 
 
9123
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
9124
}
 
9125
 
 
9126
 
 
9127
inline
 
9128
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
9129
    _bz_remainder<double,int> > >
 
9130
remainder(double d1, Range d2)
 
9131
{
 
9132
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
9133
        _bz_remainder<double,int> > T_expr;
 
9134
 
 
9135
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
9136
}
 
9137
 
 
9138
template<class P_numtype2, int N_length2>
 
9139
inline
 
9140
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9141
    _bz_remainder<double,P_numtype2> > >
 
9142
remainder(double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
9143
{
 
9144
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9145
        _bz_remainder<double,P_numtype2> > T_expr;
 
9146
 
 
9147
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
9148
}
 
9149
 
 
9150
template<class P_numtype2>
 
9151
inline
 
9152
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
9153
    _bz_remainder<long double,P_numtype2> > >
 
9154
remainder(long double d1, const Vector<P_numtype2>& d2)
 
9155
{
 
9156
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
9157
        _bz_remainder<long double,P_numtype2> > T_expr;
 
9158
 
 
9159
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
9160
}
 
9161
 
 
9162
template<class P_expr2>
 
9163
inline
 
9164
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
9165
    _bz_remainder<long double,typename P_expr2::T_numtype> > >
 
9166
remainder(long double d1, _bz_VecExpr<P_expr2> d2)
 
9167
{
 
9168
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
9169
        _bz_remainder<long double,typename P_expr2::T_numtype> > T_expr;
 
9170
 
 
9171
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
9172
}
 
9173
 
 
9174
template<class P_numtype2>
 
9175
inline
 
9176
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
9177
    _bz_remainder<long double,P_numtype2> > >
 
9178
remainder(long double d1, const VectorPick<P_numtype2>& d2)
 
9179
{
 
9180
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
9181
        _bz_remainder<long double,P_numtype2> > T_expr;
 
9182
 
 
9183
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
9184
}
 
9185
 
 
9186
 
 
9187
inline
 
9188
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
9189
    _bz_remainder<long double,int> > >
 
9190
remainder(long double d1, Range d2)
 
9191
{
 
9192
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
9193
        _bz_remainder<long double,int> > T_expr;
 
9194
 
 
9195
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
9196
}
 
9197
 
 
9198
template<class P_numtype2, int N_length2>
 
9199
inline
 
9200
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9201
    _bz_remainder<long double,P_numtype2> > >
 
9202
remainder(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
9203
{
 
9204
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9205
        _bz_remainder<long double,P_numtype2> > T_expr;
 
9206
 
 
9207
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
9208
}
 
9209
 
 
9210
template<class T1, class P_numtype2>
 
9211
inline
 
9212
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
9213
    _bz_remainder<complex<T1> ,P_numtype2> > >
 
9214
remainder(complex<T1> d1, const Vector<P_numtype2>& d2)
 
9215
{
 
9216
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
9217
        _bz_remainder<complex<T1> ,P_numtype2> > T_expr;
 
9218
 
 
9219
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
9220
}
 
9221
 
 
9222
template<class T1, class P_expr2>
 
9223
inline
 
9224
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
9225
    _bz_remainder<complex<T1> ,typename P_expr2::T_numtype> > >
 
9226
remainder(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
 
9227
{
 
9228
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
9229
        _bz_remainder<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
 
9230
 
 
9231
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
9232
}
 
9233
 
 
9234
template<class T1, class P_numtype2>
 
9235
inline
 
9236
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
9237
    _bz_remainder<complex<T1> ,P_numtype2> > >
 
9238
remainder(complex<T1> d1, const VectorPick<P_numtype2>& d2)
 
9239
{
 
9240
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
9241
        _bz_remainder<complex<T1> ,P_numtype2> > T_expr;
 
9242
 
 
9243
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
9244
}
 
9245
 
 
9246
template<class T1>
 
9247
inline
 
9248
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
9249
    _bz_remainder<complex<T1> ,int> > >
 
9250
remainder(complex<T1> d1, Range d2)
 
9251
{
 
9252
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
9253
        _bz_remainder<complex<T1> ,int> > T_expr;
 
9254
 
 
9255
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
9256
}
 
9257
 
 
9258
template<class T1, class P_numtype2, int N_length2>
 
9259
inline
 
9260
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
9261
    _bz_remainder<complex<T1> ,P_numtype2> > >
 
9262
remainder(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
9263
{
 
9264
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
9265
        _bz_remainder<complex<T1> ,P_numtype2> > T_expr;
 
9266
 
 
9267
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
9268
}
 
9269
 
 
9270
#endif
 
9271
 
 
9272
/****************************************************************************
 
9273
 * rint
 
9274
 ****************************************************************************/
 
9275
 
 
9276
#ifdef BZ_HAVE_IEEE_MATH
 
9277
template<class P_numtype1>
 
9278
inline
 
9279
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
9280
    _bz_rint<P_numtype1> > >
 
9281
rint(const Vector<P_numtype1>& d1)
 
9282
{
 
9283
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
9284
        _bz_rint<P_numtype1> > T_expr;
 
9285
 
 
9286
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
9287
}
 
9288
 
 
9289
template<class P_expr1>
 
9290
inline
 
9291
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
9292
    _bz_rint<typename P_expr1::T_numtype> > >
 
9293
rint(_bz_VecExpr<P_expr1> d1)
 
9294
{
 
9295
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
9296
        _bz_rint<typename P_expr1::T_numtype> > T_expr;
 
9297
 
 
9298
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
9299
}
 
9300
 
 
9301
template<class P_numtype1>
 
9302
inline
 
9303
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
9304
    _bz_rint<P_numtype1> > >
 
9305
rint(const VectorPick<P_numtype1>& d1)
 
9306
{
 
9307
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
9308
        _bz_rint<P_numtype1> > T_expr;
 
9309
 
 
9310
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
9311
}
 
9312
 
 
9313
 
 
9314
inline
 
9315
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
9316
    _bz_rint<int> > >
 
9317
rint(Range d1)
 
9318
{
 
9319
    typedef _bz_VecExprUnaryOp<Range,
 
9320
        _bz_rint<int> > T_expr;
 
9321
 
 
9322
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
9323
}
 
9324
 
 
9325
template<class P_numtype1, int N_length1>
 
9326
inline
 
9327
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
9328
    _bz_rint<P_numtype1> > >
 
9329
rint(const TinyVector<P_numtype1, N_length1>& d1)
 
9330
{
 
9331
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
9332
        _bz_rint<P_numtype1> > T_expr;
 
9333
 
 
9334
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
9335
}
 
9336
 
 
9337
#endif
 
9338
 
 
9339
/****************************************************************************
 
9340
 * rsqrt
 
9341
 ****************************************************************************/
 
9342
 
 
9343
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
9344
template<class P_numtype1>
 
9345
inline
 
9346
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
9347
    _bz_rsqrt<P_numtype1> > >
 
9348
rsqrt(const Vector<P_numtype1>& d1)
 
9349
{
 
9350
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
9351
        _bz_rsqrt<P_numtype1> > T_expr;
 
9352
 
 
9353
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
9354
}
 
9355
 
 
9356
template<class P_expr1>
 
9357
inline
 
9358
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
9359
    _bz_rsqrt<typename P_expr1::T_numtype> > >
 
9360
rsqrt(_bz_VecExpr<P_expr1> d1)
 
9361
{
 
9362
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
9363
        _bz_rsqrt<typename P_expr1::T_numtype> > T_expr;
 
9364
 
 
9365
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
9366
}
 
9367
 
 
9368
template<class P_numtype1>
 
9369
inline
 
9370
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
9371
    _bz_rsqrt<P_numtype1> > >
 
9372
rsqrt(const VectorPick<P_numtype1>& d1)
 
9373
{
 
9374
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
9375
        _bz_rsqrt<P_numtype1> > T_expr;
 
9376
 
 
9377
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
9378
}
 
9379
 
 
9380
 
 
9381
inline
 
9382
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
9383
    _bz_rsqrt<int> > >
 
9384
rsqrt(Range d1)
 
9385
{
 
9386
    typedef _bz_VecExprUnaryOp<Range,
 
9387
        _bz_rsqrt<int> > T_expr;
 
9388
 
 
9389
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
9390
}
 
9391
 
 
9392
template<class P_numtype1, int N_length1>
 
9393
inline
 
9394
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
9395
    _bz_rsqrt<P_numtype1> > >
 
9396
rsqrt(const TinyVector<P_numtype1, N_length1>& d1)
 
9397
{
 
9398
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
9399
        _bz_rsqrt<P_numtype1> > T_expr;
 
9400
 
 
9401
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
9402
}
 
9403
 
 
9404
#endif
 
9405
 
 
9406
/****************************************************************************
 
9407
 * scalb
 
9408
 ****************************************************************************/
 
9409
 
 
9410
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
9411
template<class P_numtype1, class P_numtype2>
 
9412
inline
 
9413
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
9414
    _bz_scalb<P_numtype1,P_numtype2> > >
 
9415
scalb(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
9416
{
 
9417
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
9418
        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
 
9419
 
 
9420
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
9421
}
 
9422
 
 
9423
template<class P_numtype1, class P_expr2>
 
9424
inline
 
9425
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
9426
    _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > >
 
9427
scalb(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
9428
{
 
9429
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
9430
        _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
9431
 
 
9432
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
9433
}
 
9434
 
 
9435
template<class P_numtype1, class P_numtype2>
 
9436
inline
 
9437
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
9438
    _bz_scalb<P_numtype1,P_numtype2> > >
 
9439
scalb(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
9440
{
 
9441
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
9442
        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
 
9443
 
 
9444
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
9445
}
 
9446
 
 
9447
template<class P_numtype1>
 
9448
inline
 
9449
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
9450
    _bz_scalb<P_numtype1,int> > >
 
9451
scalb(const Vector<P_numtype1>& d1, Range d2)
 
9452
{
 
9453
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
9454
        _bz_scalb<P_numtype1,int> > T_expr;
 
9455
 
 
9456
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
9457
}
 
9458
 
 
9459
template<class P_numtype1, class P_numtype2, int N_length2>
 
9460
inline
 
9461
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9462
    _bz_scalb<P_numtype1,P_numtype2> > >
 
9463
scalb(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
9464
{
 
9465
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9466
        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
 
9467
 
 
9468
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
9469
}
 
9470
 
 
9471
template<class P_numtype1>
 
9472
inline
 
9473
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
9474
    _bz_scalb<P_numtype1,int> > >
 
9475
scalb(const Vector<P_numtype1>& d1, int d2)
 
9476
{
 
9477
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
9478
        _bz_scalb<P_numtype1,int> > T_expr;
 
9479
 
 
9480
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
9481
}
 
9482
 
 
9483
template<class P_numtype1>
 
9484
inline
 
9485
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
9486
    _bz_scalb<P_numtype1,float> > >
 
9487
scalb(const Vector<P_numtype1>& d1, float d2)
 
9488
{
 
9489
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
9490
        _bz_scalb<P_numtype1,float> > T_expr;
 
9491
 
 
9492
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
9493
}
 
9494
 
 
9495
template<class P_numtype1>
 
9496
inline
 
9497
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
9498
    _bz_scalb<P_numtype1,double> > >
 
9499
scalb(const Vector<P_numtype1>& d1, double d2)
 
9500
{
 
9501
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
9502
        _bz_scalb<P_numtype1,double> > T_expr;
 
9503
 
 
9504
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
9505
}
 
9506
 
 
9507
template<class P_numtype1>
 
9508
inline
 
9509
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
9510
    _bz_scalb<P_numtype1,long double> > >
 
9511
scalb(const Vector<P_numtype1>& d1, long double d2)
 
9512
{
 
9513
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
9514
        _bz_scalb<P_numtype1,long double> > T_expr;
 
9515
 
 
9516
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
9517
}
 
9518
 
 
9519
template<class P_numtype1, class T2>
 
9520
inline
 
9521
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
9522
    _bz_scalb<P_numtype1,complex<T2> > > >
 
9523
scalb(const Vector<P_numtype1>& d1, complex<T2> d2)
 
9524
{
 
9525
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
9526
        _bz_scalb<P_numtype1,complex<T2> > > T_expr;
 
9527
 
 
9528
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
9529
}
 
9530
 
 
9531
template<class P_expr1, class P_numtype2>
 
9532
inline
 
9533
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
9534
    _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > >
 
9535
scalb(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
 
9536
{
 
9537
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
9538
        _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
9539
 
 
9540
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
9541
}
 
9542
 
 
9543
template<class P_expr1, class P_expr2>
 
9544
inline
 
9545
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
9546
    _bz_scalb<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
 
9547
scalb(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
 
9548
{
 
9549
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
9550
        _bz_scalb<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
 
9551
 
 
9552
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
9553
}
 
9554
 
 
9555
template<class P_expr1, class P_numtype2>
 
9556
inline
 
9557
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
9558
    _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > >
 
9559
scalb(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
 
9560
{
 
9561
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
9562
        _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
9563
 
 
9564
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
9565
}
 
9566
 
 
9567
template<class P_expr1>
 
9568
inline
 
9569
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
9570
    _bz_scalb<typename P_expr1::T_numtype,int> > >
 
9571
scalb(_bz_VecExpr<P_expr1> d1, Range d2)
 
9572
{
 
9573
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
9574
        _bz_scalb<typename P_expr1::T_numtype,int> > T_expr;
 
9575
 
 
9576
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
9577
}
 
9578
 
 
9579
template<class P_expr1, class P_numtype2, int N_length2>
 
9580
inline
 
9581
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9582
    _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > >
 
9583
scalb(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
9584
{
 
9585
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9586
        _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
9587
 
 
9588
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
9589
}
 
9590
 
 
9591
template<class P_expr1>
 
9592
inline
 
9593
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
9594
    _bz_scalb<typename P_expr1::T_numtype,int> > >
 
9595
scalb(_bz_VecExpr<P_expr1> d1, int d2)
 
9596
{
 
9597
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
9598
        _bz_scalb<typename P_expr1::T_numtype,int> > T_expr;
 
9599
 
 
9600
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
9601
}
 
9602
 
 
9603
template<class P_expr1>
 
9604
inline
 
9605
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
9606
    _bz_scalb<typename P_expr1::T_numtype,float> > >
 
9607
scalb(_bz_VecExpr<P_expr1> d1, float d2)
 
9608
{
 
9609
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
9610
        _bz_scalb<typename P_expr1::T_numtype,float> > T_expr;
 
9611
 
 
9612
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
9613
}
 
9614
 
 
9615
template<class P_expr1>
 
9616
inline
 
9617
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
9618
    _bz_scalb<typename P_expr1::T_numtype,double> > >
 
9619
scalb(_bz_VecExpr<P_expr1> d1, double d2)
 
9620
{
 
9621
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
9622
        _bz_scalb<typename P_expr1::T_numtype,double> > T_expr;
 
9623
 
 
9624
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
9625
}
 
9626
 
 
9627
template<class P_expr1>
 
9628
inline
 
9629
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
9630
    _bz_scalb<typename P_expr1::T_numtype,long double> > >
 
9631
scalb(_bz_VecExpr<P_expr1> d1, long double d2)
 
9632
{
 
9633
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
9634
        _bz_scalb<typename P_expr1::T_numtype,long double> > T_expr;
 
9635
 
 
9636
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
9637
}
 
9638
 
 
9639
template<class P_expr1, class T2>
 
9640
inline
 
9641
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
9642
    _bz_scalb<typename P_expr1::T_numtype,complex<T2> > > >
 
9643
scalb(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
 
9644
{
 
9645
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
9646
        _bz_scalb<typename P_expr1::T_numtype,complex<T2> > > T_expr;
 
9647
 
 
9648
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
9649
}
 
9650
 
 
9651
template<class P_numtype1, class P_numtype2>
 
9652
inline
 
9653
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
9654
    _bz_scalb<P_numtype1,P_numtype2> > >
 
9655
scalb(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
9656
{
 
9657
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
9658
        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
 
9659
 
 
9660
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
9661
}
 
9662
 
 
9663
template<class P_numtype1, class P_expr2>
 
9664
inline
 
9665
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
9666
    _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > >
 
9667
scalb(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
9668
{
 
9669
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
9670
        _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
9671
 
 
9672
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
9673
}
 
9674
 
 
9675
template<class P_numtype1, class P_numtype2>
 
9676
inline
 
9677
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
9678
    _bz_scalb<P_numtype1,P_numtype2> > >
 
9679
scalb(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
9680
{
 
9681
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
9682
        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
 
9683
 
 
9684
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
9685
}
 
9686
 
 
9687
template<class P_numtype1>
 
9688
inline
 
9689
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
9690
    _bz_scalb<P_numtype1,int> > >
 
9691
scalb(const VectorPick<P_numtype1>& d1, Range d2)
 
9692
{
 
9693
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
9694
        _bz_scalb<P_numtype1,int> > T_expr;
 
9695
 
 
9696
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
9697
}
 
9698
 
 
9699
template<class P_numtype1, class P_numtype2, int N_length2>
 
9700
inline
 
9701
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9702
    _bz_scalb<P_numtype1,P_numtype2> > >
 
9703
scalb(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
9704
{
 
9705
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9706
        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
 
9707
 
 
9708
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
9709
}
 
9710
 
 
9711
template<class P_numtype1>
 
9712
inline
 
9713
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
9714
    _bz_scalb<P_numtype1,int> > >
 
9715
scalb(const VectorPick<P_numtype1>& d1, int d2)
 
9716
{
 
9717
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
9718
        _bz_scalb<P_numtype1,int> > T_expr;
 
9719
 
 
9720
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
9721
}
 
9722
 
 
9723
template<class P_numtype1>
 
9724
inline
 
9725
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
9726
    _bz_scalb<P_numtype1,float> > >
 
9727
scalb(const VectorPick<P_numtype1>& d1, float d2)
 
9728
{
 
9729
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
9730
        _bz_scalb<P_numtype1,float> > T_expr;
 
9731
 
 
9732
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
9733
}
 
9734
 
 
9735
template<class P_numtype1>
 
9736
inline
 
9737
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
9738
    _bz_scalb<P_numtype1,double> > >
 
9739
scalb(const VectorPick<P_numtype1>& d1, double d2)
 
9740
{
 
9741
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
9742
        _bz_scalb<P_numtype1,double> > T_expr;
 
9743
 
 
9744
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
9745
}
 
9746
 
 
9747
template<class P_numtype1>
 
9748
inline
 
9749
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
9750
    _bz_scalb<P_numtype1,long double> > >
 
9751
scalb(const VectorPick<P_numtype1>& d1, long double d2)
 
9752
{
 
9753
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
9754
        _bz_scalb<P_numtype1,long double> > T_expr;
 
9755
 
 
9756
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
9757
}
 
9758
 
 
9759
template<class P_numtype1, class T2>
 
9760
inline
 
9761
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
9762
    _bz_scalb<P_numtype1,complex<T2> > > >
 
9763
scalb(const VectorPick<P_numtype1>& d1, complex<T2> d2)
 
9764
{
 
9765
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
9766
        _bz_scalb<P_numtype1,complex<T2> > > T_expr;
 
9767
 
 
9768
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
9769
}
 
9770
 
 
9771
template<class P_numtype2>
 
9772
inline
 
9773
_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
9774
    _bz_scalb<int,P_numtype2> > >
 
9775
scalb(Range d1, const Vector<P_numtype2>& d2)
 
9776
{
 
9777
    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
9778
        _bz_scalb<int,P_numtype2> > T_expr;
 
9779
 
 
9780
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
9781
}
 
9782
 
 
9783
template<class P_expr2>
 
9784
inline
 
9785
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
9786
    _bz_scalb<int,typename P_expr2::T_numtype> > >
 
9787
scalb(Range d1, _bz_VecExpr<P_expr2> d2)
 
9788
{
 
9789
    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
9790
        _bz_scalb<int,typename P_expr2::T_numtype> > T_expr;
 
9791
 
 
9792
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
9793
}
 
9794
 
 
9795
template<class P_numtype2>
 
9796
inline
 
9797
_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
9798
    _bz_scalb<int,P_numtype2> > >
 
9799
scalb(Range d1, const VectorPick<P_numtype2>& d2)
 
9800
{
 
9801
    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
9802
        _bz_scalb<int,P_numtype2> > T_expr;
 
9803
 
 
9804
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
9805
}
 
9806
 
 
9807
 
 
9808
inline
 
9809
_bz_VecExpr<_bz_VecExprOp<Range, Range,
 
9810
    _bz_scalb<int,int> > >
 
9811
scalb(Range d1, Range d2)
 
9812
{
 
9813
    typedef _bz_VecExprOp<Range, Range,
 
9814
        _bz_scalb<int,int> > T_expr;
 
9815
 
 
9816
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
9817
}
 
9818
 
 
9819
template<class P_numtype2, int N_length2>
 
9820
inline
 
9821
_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
9822
    _bz_scalb<int,P_numtype2> > >
 
9823
scalb(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
 
9824
{
 
9825
    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
9826
        _bz_scalb<int,P_numtype2> > T_expr;
 
9827
 
 
9828
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
9829
}
 
9830
 
 
9831
 
 
9832
inline
 
9833
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
9834
    _bz_scalb<int,int> > >
 
9835
scalb(Range d1, int d2)
 
9836
{
 
9837
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
9838
        _bz_scalb<int,int> > T_expr;
 
9839
 
 
9840
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
9841
}
 
9842
 
 
9843
 
 
9844
inline
 
9845
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
9846
    _bz_scalb<int,float> > >
 
9847
scalb(Range d1, float d2)
 
9848
{
 
9849
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
9850
        _bz_scalb<int,float> > T_expr;
 
9851
 
 
9852
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
9853
}
 
9854
 
 
9855
 
 
9856
inline
 
9857
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
9858
    _bz_scalb<int,double> > >
 
9859
scalb(Range d1, double d2)
 
9860
{
 
9861
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
9862
        _bz_scalb<int,double> > T_expr;
 
9863
 
 
9864
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
9865
}
 
9866
 
 
9867
 
 
9868
inline
 
9869
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
9870
    _bz_scalb<int,long double> > >
 
9871
scalb(Range d1, long double d2)
 
9872
{
 
9873
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
9874
        _bz_scalb<int,long double> > T_expr;
 
9875
 
 
9876
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
9877
}
 
9878
 
 
9879
template<class T2>
 
9880
inline
 
9881
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
9882
    _bz_scalb<int,complex<T2> > > >
 
9883
scalb(Range d1, complex<T2> d2)
 
9884
{
 
9885
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
9886
        _bz_scalb<int,complex<T2> > > T_expr;
 
9887
 
 
9888
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
9889
}
 
9890
 
 
9891
template<class P_numtype1, int N_length1, class P_numtype2>
 
9892
inline
 
9893
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
9894
    _bz_scalb<P_numtype1,P_numtype2> > >
 
9895
scalb(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
 
9896
{
 
9897
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
9898
        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
 
9899
 
 
9900
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
9901
}
 
9902
 
 
9903
template<class P_numtype1, int N_length1, class P_expr2>
 
9904
inline
 
9905
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
9906
    _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > >
 
9907
scalb(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
 
9908
{
 
9909
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
9910
        _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
9911
 
 
9912
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
9913
}
 
9914
 
 
9915
template<class P_numtype1, int N_length1, class P_numtype2>
 
9916
inline
 
9917
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
9918
    _bz_scalb<P_numtype1,P_numtype2> > >
 
9919
scalb(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
 
9920
{
 
9921
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
9922
        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
 
9923
 
 
9924
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
9925
}
 
9926
 
 
9927
template<class P_numtype1, int N_length1>
 
9928
inline
 
9929
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
9930
    _bz_scalb<P_numtype1,int> > >
 
9931
scalb(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
 
9932
{
 
9933
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
9934
        _bz_scalb<P_numtype1,int> > T_expr;
 
9935
 
 
9936
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
9937
}
 
9938
 
 
9939
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
 
9940
inline
 
9941
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9942
    _bz_scalb<P_numtype1,P_numtype2> > >
 
9943
scalb(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
9944
{
 
9945
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
9946
        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
 
9947
 
 
9948
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
9949
}
 
9950
 
 
9951
template<class P_numtype1, int N_length1>
 
9952
inline
 
9953
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
9954
    _bz_scalb<P_numtype1,int> > >
 
9955
scalb(const TinyVector<P_numtype1, N_length1>& d1, int d2)
 
9956
{
 
9957
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
9958
        _bz_scalb<P_numtype1,int> > T_expr;
 
9959
 
 
9960
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
9961
}
 
9962
 
 
9963
template<class P_numtype1, int N_length1>
 
9964
inline
 
9965
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
9966
    _bz_scalb<P_numtype1,float> > >
 
9967
scalb(const TinyVector<P_numtype1, N_length1>& d1, float d2)
 
9968
{
 
9969
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
9970
        _bz_scalb<P_numtype1,float> > T_expr;
 
9971
 
 
9972
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
9973
}
 
9974
 
 
9975
template<class P_numtype1, int N_length1>
 
9976
inline
 
9977
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
9978
    _bz_scalb<P_numtype1,double> > >
 
9979
scalb(const TinyVector<P_numtype1, N_length1>& d1, double d2)
 
9980
{
 
9981
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
9982
        _bz_scalb<P_numtype1,double> > T_expr;
 
9983
 
 
9984
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
9985
}
 
9986
 
 
9987
template<class P_numtype1, int N_length1>
 
9988
inline
 
9989
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
9990
    _bz_scalb<P_numtype1,long double> > >
 
9991
scalb(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
 
9992
{
 
9993
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
9994
        _bz_scalb<P_numtype1,long double> > T_expr;
 
9995
 
 
9996
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
9997
}
 
9998
 
 
9999
template<class P_numtype1, int N_length1, class T2>
 
10000
inline
 
10001
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
10002
    _bz_scalb<P_numtype1,complex<T2> > > >
 
10003
scalb(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
 
10004
{
 
10005
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
10006
        _bz_scalb<P_numtype1,complex<T2> > > T_expr;
 
10007
 
 
10008
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
10009
}
 
10010
 
 
10011
template<class P_numtype2>
 
10012
inline
 
10013
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
10014
    _bz_scalb<int,P_numtype2> > >
 
10015
scalb(int d1, const Vector<P_numtype2>& d2)
 
10016
{
 
10017
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
10018
        _bz_scalb<int,P_numtype2> > T_expr;
 
10019
 
 
10020
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
10021
}
 
10022
 
 
10023
template<class P_expr2>
 
10024
inline
 
10025
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
10026
    _bz_scalb<int,typename P_expr2::T_numtype> > >
 
10027
scalb(int d1, _bz_VecExpr<P_expr2> d2)
 
10028
{
 
10029
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
10030
        _bz_scalb<int,typename P_expr2::T_numtype> > T_expr;
 
10031
 
 
10032
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
10033
}
 
10034
 
 
10035
template<class P_numtype2>
 
10036
inline
 
10037
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
10038
    _bz_scalb<int,P_numtype2> > >
 
10039
scalb(int d1, const VectorPick<P_numtype2>& d2)
 
10040
{
 
10041
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
10042
        _bz_scalb<int,P_numtype2> > T_expr;
 
10043
 
 
10044
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
10045
}
 
10046
 
 
10047
 
 
10048
inline
 
10049
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
10050
    _bz_scalb<int,int> > >
 
10051
scalb(int d1, Range d2)
 
10052
{
 
10053
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
10054
        _bz_scalb<int,int> > T_expr;
 
10055
 
 
10056
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
10057
}
 
10058
 
 
10059
template<class P_numtype2, int N_length2>
 
10060
inline
 
10061
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10062
    _bz_scalb<int,P_numtype2> > >
 
10063
scalb(int d1, const TinyVector<P_numtype2, N_length2>& d2)
 
10064
{
 
10065
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10066
        _bz_scalb<int,P_numtype2> > T_expr;
 
10067
 
 
10068
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
10069
}
 
10070
 
 
10071
template<class P_numtype2>
 
10072
inline
 
10073
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
10074
    _bz_scalb<float,P_numtype2> > >
 
10075
scalb(float d1, const Vector<P_numtype2>& d2)
 
10076
{
 
10077
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
10078
        _bz_scalb<float,P_numtype2> > T_expr;
 
10079
 
 
10080
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
10081
}
 
10082
 
 
10083
template<class P_expr2>
 
10084
inline
 
10085
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
10086
    _bz_scalb<float,typename P_expr2::T_numtype> > >
 
10087
scalb(float d1, _bz_VecExpr<P_expr2> d2)
 
10088
{
 
10089
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
10090
        _bz_scalb<float,typename P_expr2::T_numtype> > T_expr;
 
10091
 
 
10092
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
10093
}
 
10094
 
 
10095
template<class P_numtype2>
 
10096
inline
 
10097
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
10098
    _bz_scalb<float,P_numtype2> > >
 
10099
scalb(float d1, const VectorPick<P_numtype2>& d2)
 
10100
{
 
10101
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
10102
        _bz_scalb<float,P_numtype2> > T_expr;
 
10103
 
 
10104
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
10105
}
 
10106
 
 
10107
 
 
10108
inline
 
10109
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
10110
    _bz_scalb<float,int> > >
 
10111
scalb(float d1, Range d2)
 
10112
{
 
10113
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
10114
        _bz_scalb<float,int> > T_expr;
 
10115
 
 
10116
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
10117
}
 
10118
 
 
10119
template<class P_numtype2, int N_length2>
 
10120
inline
 
10121
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10122
    _bz_scalb<float,P_numtype2> > >
 
10123
scalb(float d1, const TinyVector<P_numtype2, N_length2>& d2)
 
10124
{
 
10125
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10126
        _bz_scalb<float,P_numtype2> > T_expr;
 
10127
 
 
10128
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
10129
}
 
10130
 
 
10131
template<class P_numtype2>
 
10132
inline
 
10133
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
10134
    _bz_scalb<double,P_numtype2> > >
 
10135
scalb(double d1, const Vector<P_numtype2>& d2)
 
10136
{
 
10137
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
10138
        _bz_scalb<double,P_numtype2> > T_expr;
 
10139
 
 
10140
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
10141
}
 
10142
 
 
10143
template<class P_expr2>
 
10144
inline
 
10145
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
10146
    _bz_scalb<double,typename P_expr2::T_numtype> > >
 
10147
scalb(double d1, _bz_VecExpr<P_expr2> d2)
 
10148
{
 
10149
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
10150
        _bz_scalb<double,typename P_expr2::T_numtype> > T_expr;
 
10151
 
 
10152
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
10153
}
 
10154
 
 
10155
template<class P_numtype2>
 
10156
inline
 
10157
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
10158
    _bz_scalb<double,P_numtype2> > >
 
10159
scalb(double d1, const VectorPick<P_numtype2>& d2)
 
10160
{
 
10161
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
10162
        _bz_scalb<double,P_numtype2> > T_expr;
 
10163
 
 
10164
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
10165
}
 
10166
 
 
10167
 
 
10168
inline
 
10169
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
10170
    _bz_scalb<double,int> > >
 
10171
scalb(double d1, Range d2)
 
10172
{
 
10173
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
10174
        _bz_scalb<double,int> > T_expr;
 
10175
 
 
10176
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
10177
}
 
10178
 
 
10179
template<class P_numtype2, int N_length2>
 
10180
inline
 
10181
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10182
    _bz_scalb<double,P_numtype2> > >
 
10183
scalb(double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
10184
{
 
10185
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10186
        _bz_scalb<double,P_numtype2> > T_expr;
 
10187
 
 
10188
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
10189
}
 
10190
 
 
10191
template<class P_numtype2>
 
10192
inline
 
10193
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
10194
    _bz_scalb<long double,P_numtype2> > >
 
10195
scalb(long double d1, const Vector<P_numtype2>& d2)
 
10196
{
 
10197
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
10198
        _bz_scalb<long double,P_numtype2> > T_expr;
 
10199
 
 
10200
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
10201
}
 
10202
 
 
10203
template<class P_expr2>
 
10204
inline
 
10205
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
10206
    _bz_scalb<long double,typename P_expr2::T_numtype> > >
 
10207
scalb(long double d1, _bz_VecExpr<P_expr2> d2)
 
10208
{
 
10209
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
10210
        _bz_scalb<long double,typename P_expr2::T_numtype> > T_expr;
 
10211
 
 
10212
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
10213
}
 
10214
 
 
10215
template<class P_numtype2>
 
10216
inline
 
10217
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
10218
    _bz_scalb<long double,P_numtype2> > >
 
10219
scalb(long double d1, const VectorPick<P_numtype2>& d2)
 
10220
{
 
10221
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
10222
        _bz_scalb<long double,P_numtype2> > T_expr;
 
10223
 
 
10224
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
10225
}
 
10226
 
 
10227
 
 
10228
inline
 
10229
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
10230
    _bz_scalb<long double,int> > >
 
10231
scalb(long double d1, Range d2)
 
10232
{
 
10233
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
10234
        _bz_scalb<long double,int> > T_expr;
 
10235
 
 
10236
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
10237
}
 
10238
 
 
10239
template<class P_numtype2, int N_length2>
 
10240
inline
 
10241
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10242
    _bz_scalb<long double,P_numtype2> > >
 
10243
scalb(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
10244
{
 
10245
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10246
        _bz_scalb<long double,P_numtype2> > T_expr;
 
10247
 
 
10248
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
10249
}
 
10250
 
 
10251
template<class T1, class P_numtype2>
 
10252
inline
 
10253
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
10254
    _bz_scalb<complex<T1> ,P_numtype2> > >
 
10255
scalb(complex<T1> d1, const Vector<P_numtype2>& d2)
 
10256
{
 
10257
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
10258
        _bz_scalb<complex<T1> ,P_numtype2> > T_expr;
 
10259
 
 
10260
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
10261
}
 
10262
 
 
10263
template<class T1, class P_expr2>
 
10264
inline
 
10265
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
10266
    _bz_scalb<complex<T1> ,typename P_expr2::T_numtype> > >
 
10267
scalb(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
 
10268
{
 
10269
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
10270
        _bz_scalb<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
 
10271
 
 
10272
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
10273
}
 
10274
 
 
10275
template<class T1, class P_numtype2>
 
10276
inline
 
10277
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
10278
    _bz_scalb<complex<T1> ,P_numtype2> > >
 
10279
scalb(complex<T1> d1, const VectorPick<P_numtype2>& d2)
 
10280
{
 
10281
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
10282
        _bz_scalb<complex<T1> ,P_numtype2> > T_expr;
 
10283
 
 
10284
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
10285
}
 
10286
 
 
10287
template<class T1>
 
10288
inline
 
10289
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
10290
    _bz_scalb<complex<T1> ,int> > >
 
10291
scalb(complex<T1> d1, Range d2)
 
10292
{
 
10293
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
10294
        _bz_scalb<complex<T1> ,int> > T_expr;
 
10295
 
 
10296
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
10297
}
 
10298
 
 
10299
template<class T1, class P_numtype2, int N_length2>
 
10300
inline
 
10301
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
10302
    _bz_scalb<complex<T1> ,P_numtype2> > >
 
10303
scalb(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
10304
{
 
10305
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
10306
        _bz_scalb<complex<T1> ,P_numtype2> > T_expr;
 
10307
 
 
10308
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
10309
}
 
10310
 
 
10311
#endif
 
10312
 
 
10313
/****************************************************************************
 
10314
 * sin
 
10315
 ****************************************************************************/
 
10316
 
 
10317
template<class P_numtype1>
 
10318
inline
 
10319
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10320
    _bz_sin<P_numtype1> > >
 
10321
sin(const Vector<P_numtype1>& d1)
 
10322
{
 
10323
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10324
        _bz_sin<P_numtype1> > T_expr;
 
10325
 
 
10326
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10327
}
 
10328
 
 
10329
template<class P_expr1>
 
10330
inline
 
10331
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10332
    _bz_sin<typename P_expr1::T_numtype> > >
 
10333
sin(_bz_VecExpr<P_expr1> d1)
 
10334
{
 
10335
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10336
        _bz_sin<typename P_expr1::T_numtype> > T_expr;
 
10337
 
 
10338
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10339
}
 
10340
 
 
10341
template<class P_numtype1>
 
10342
inline
 
10343
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10344
    _bz_sin<P_numtype1> > >
 
10345
sin(const VectorPick<P_numtype1>& d1)
 
10346
{
 
10347
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10348
        _bz_sin<P_numtype1> > T_expr;
 
10349
 
 
10350
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10351
}
 
10352
 
 
10353
 
 
10354
inline
 
10355
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
10356
    _bz_sin<int> > >
 
10357
sin(Range d1)
 
10358
{
 
10359
    typedef _bz_VecExprUnaryOp<Range,
 
10360
        _bz_sin<int> > T_expr;
 
10361
 
 
10362
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10363
}
 
10364
 
 
10365
template<class P_numtype1, int N_length1>
 
10366
inline
 
10367
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10368
    _bz_sin<P_numtype1> > >
 
10369
sin(const TinyVector<P_numtype1, N_length1>& d1)
 
10370
{
 
10371
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10372
        _bz_sin<P_numtype1> > T_expr;
 
10373
 
 
10374
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10375
}
 
10376
 
 
10377
 
 
10378
/****************************************************************************
 
10379
 * sinh
 
10380
 ****************************************************************************/
 
10381
 
 
10382
template<class P_numtype1>
 
10383
inline
 
10384
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10385
    _bz_sinh<P_numtype1> > >
 
10386
sinh(const Vector<P_numtype1>& d1)
 
10387
{
 
10388
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10389
        _bz_sinh<P_numtype1> > T_expr;
 
10390
 
 
10391
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10392
}
 
10393
 
 
10394
template<class P_expr1>
 
10395
inline
 
10396
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10397
    _bz_sinh<typename P_expr1::T_numtype> > >
 
10398
sinh(_bz_VecExpr<P_expr1> d1)
 
10399
{
 
10400
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10401
        _bz_sinh<typename P_expr1::T_numtype> > T_expr;
 
10402
 
 
10403
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10404
}
 
10405
 
 
10406
template<class P_numtype1>
 
10407
inline
 
10408
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10409
    _bz_sinh<P_numtype1> > >
 
10410
sinh(const VectorPick<P_numtype1>& d1)
 
10411
{
 
10412
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10413
        _bz_sinh<P_numtype1> > T_expr;
 
10414
 
 
10415
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10416
}
 
10417
 
 
10418
 
 
10419
inline
 
10420
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
10421
    _bz_sinh<int> > >
 
10422
sinh(Range d1)
 
10423
{
 
10424
    typedef _bz_VecExprUnaryOp<Range,
 
10425
        _bz_sinh<int> > T_expr;
 
10426
 
 
10427
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10428
}
 
10429
 
 
10430
template<class P_numtype1, int N_length1>
 
10431
inline
 
10432
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10433
    _bz_sinh<P_numtype1> > >
 
10434
sinh(const TinyVector<P_numtype1, N_length1>& d1)
 
10435
{
 
10436
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10437
        _bz_sinh<P_numtype1> > T_expr;
 
10438
 
 
10439
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10440
}
 
10441
 
 
10442
 
 
10443
/****************************************************************************
 
10444
 * sqr
 
10445
 ****************************************************************************/
 
10446
 
 
10447
template<class P_numtype1>
 
10448
inline
 
10449
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10450
    _bz_sqr<P_numtype1> > >
 
10451
sqr(const Vector<P_numtype1>& d1)
 
10452
{
 
10453
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10454
        _bz_sqr<P_numtype1> > T_expr;
 
10455
 
 
10456
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10457
}
 
10458
 
 
10459
template<class P_expr1>
 
10460
inline
 
10461
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10462
    _bz_sqr<typename P_expr1::T_numtype> > >
 
10463
sqr(_bz_VecExpr<P_expr1> d1)
 
10464
{
 
10465
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10466
        _bz_sqr<typename P_expr1::T_numtype> > T_expr;
 
10467
 
 
10468
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10469
}
 
10470
 
 
10471
template<class P_numtype1>
 
10472
inline
 
10473
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10474
    _bz_sqr<P_numtype1> > >
 
10475
sqr(const VectorPick<P_numtype1>& d1)
 
10476
{
 
10477
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10478
        _bz_sqr<P_numtype1> > T_expr;
 
10479
 
 
10480
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10481
}
 
10482
 
 
10483
 
 
10484
inline
 
10485
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
10486
    _bz_sqr<int> > >
 
10487
sqr(Range d1)
 
10488
{
 
10489
    typedef _bz_VecExprUnaryOp<Range,
 
10490
        _bz_sqr<int> > T_expr;
 
10491
 
 
10492
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10493
}
 
10494
 
 
10495
template<class P_numtype1, int N_length1>
 
10496
inline
 
10497
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10498
    _bz_sqr<P_numtype1> > >
 
10499
sqr(const TinyVector<P_numtype1, N_length1>& d1)
 
10500
{
 
10501
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10502
        _bz_sqr<P_numtype1> > T_expr;
 
10503
 
 
10504
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10505
}
 
10506
 
 
10507
 
 
10508
/****************************************************************************
 
10509
 * sqrt
 
10510
 ****************************************************************************/
 
10511
 
 
10512
template<class P_numtype1>
 
10513
inline
 
10514
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10515
    _bz_sqrt<P_numtype1> > >
 
10516
sqrt(const Vector<P_numtype1>& d1)
 
10517
{
 
10518
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10519
        _bz_sqrt<P_numtype1> > T_expr;
 
10520
 
 
10521
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10522
}
 
10523
 
 
10524
template<class P_expr1>
 
10525
inline
 
10526
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10527
    _bz_sqrt<typename P_expr1::T_numtype> > >
 
10528
sqrt(_bz_VecExpr<P_expr1> d1)
 
10529
{
 
10530
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10531
        _bz_sqrt<typename P_expr1::T_numtype> > T_expr;
 
10532
 
 
10533
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10534
}
 
10535
 
 
10536
template<class P_numtype1>
 
10537
inline
 
10538
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10539
    _bz_sqrt<P_numtype1> > >
 
10540
sqrt(const VectorPick<P_numtype1>& d1)
 
10541
{
 
10542
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10543
        _bz_sqrt<P_numtype1> > T_expr;
 
10544
 
 
10545
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10546
}
 
10547
 
 
10548
 
 
10549
inline
 
10550
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
10551
    _bz_sqrt<int> > >
 
10552
sqrt(Range d1)
 
10553
{
 
10554
    typedef _bz_VecExprUnaryOp<Range,
 
10555
        _bz_sqrt<int> > T_expr;
 
10556
 
 
10557
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10558
}
 
10559
 
 
10560
template<class P_numtype1, int N_length1>
 
10561
inline
 
10562
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10563
    _bz_sqrt<P_numtype1> > >
 
10564
sqrt(const TinyVector<P_numtype1, N_length1>& d1)
 
10565
{
 
10566
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10567
        _bz_sqrt<P_numtype1> > T_expr;
 
10568
 
 
10569
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10570
}
 
10571
 
 
10572
 
 
10573
/****************************************************************************
 
10574
 * tan
 
10575
 ****************************************************************************/
 
10576
 
 
10577
template<class P_numtype1>
 
10578
inline
 
10579
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10580
    _bz_tan<P_numtype1> > >
 
10581
tan(const Vector<P_numtype1>& d1)
 
10582
{
 
10583
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10584
        _bz_tan<P_numtype1> > T_expr;
 
10585
 
 
10586
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10587
}
 
10588
 
 
10589
template<class P_expr1>
 
10590
inline
 
10591
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10592
    _bz_tan<typename P_expr1::T_numtype> > >
 
10593
tan(_bz_VecExpr<P_expr1> d1)
 
10594
{
 
10595
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10596
        _bz_tan<typename P_expr1::T_numtype> > T_expr;
 
10597
 
 
10598
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10599
}
 
10600
 
 
10601
template<class P_numtype1>
 
10602
inline
 
10603
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10604
    _bz_tan<P_numtype1> > >
 
10605
tan(const VectorPick<P_numtype1>& d1)
 
10606
{
 
10607
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10608
        _bz_tan<P_numtype1> > T_expr;
 
10609
 
 
10610
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10611
}
 
10612
 
 
10613
 
 
10614
inline
 
10615
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
10616
    _bz_tan<int> > >
 
10617
tan(Range d1)
 
10618
{
 
10619
    typedef _bz_VecExprUnaryOp<Range,
 
10620
        _bz_tan<int> > T_expr;
 
10621
 
 
10622
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10623
}
 
10624
 
 
10625
template<class P_numtype1, int N_length1>
 
10626
inline
 
10627
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10628
    _bz_tan<P_numtype1> > >
 
10629
tan(const TinyVector<P_numtype1, N_length1>& d1)
 
10630
{
 
10631
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10632
        _bz_tan<P_numtype1> > T_expr;
 
10633
 
 
10634
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10635
}
 
10636
 
 
10637
 
 
10638
/****************************************************************************
 
10639
 * tanh
 
10640
 ****************************************************************************/
 
10641
 
 
10642
template<class P_numtype1>
 
10643
inline
 
10644
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10645
    _bz_tanh<P_numtype1> > >
 
10646
tanh(const Vector<P_numtype1>& d1)
 
10647
{
 
10648
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10649
        _bz_tanh<P_numtype1> > T_expr;
 
10650
 
 
10651
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10652
}
 
10653
 
 
10654
template<class P_expr1>
 
10655
inline
 
10656
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10657
    _bz_tanh<typename P_expr1::T_numtype> > >
 
10658
tanh(_bz_VecExpr<P_expr1> d1)
 
10659
{
 
10660
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10661
        _bz_tanh<typename P_expr1::T_numtype> > T_expr;
 
10662
 
 
10663
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10664
}
 
10665
 
 
10666
template<class P_numtype1>
 
10667
inline
 
10668
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10669
    _bz_tanh<P_numtype1> > >
 
10670
tanh(const VectorPick<P_numtype1>& d1)
 
10671
{
 
10672
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10673
        _bz_tanh<P_numtype1> > T_expr;
 
10674
 
 
10675
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10676
}
 
10677
 
 
10678
 
 
10679
inline
 
10680
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
10681
    _bz_tanh<int> > >
 
10682
tanh(Range d1)
 
10683
{
 
10684
    typedef _bz_VecExprUnaryOp<Range,
 
10685
        _bz_tanh<int> > T_expr;
 
10686
 
 
10687
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10688
}
 
10689
 
 
10690
template<class P_numtype1, int N_length1>
 
10691
inline
 
10692
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10693
    _bz_tanh<P_numtype1> > >
 
10694
tanh(const TinyVector<P_numtype1, N_length1>& d1)
 
10695
{
 
10696
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10697
        _bz_tanh<P_numtype1> > T_expr;
 
10698
 
 
10699
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10700
}
 
10701
 
 
10702
 
 
10703
/****************************************************************************
 
10704
 * uitrunc
 
10705
 ****************************************************************************/
 
10706
 
 
10707
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
10708
template<class P_numtype1>
 
10709
inline
 
10710
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10711
    _bz_uitrunc<P_numtype1> > >
 
10712
uitrunc(const Vector<P_numtype1>& d1)
 
10713
{
 
10714
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
10715
        _bz_uitrunc<P_numtype1> > T_expr;
 
10716
 
 
10717
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10718
}
 
10719
 
 
10720
template<class P_expr1>
 
10721
inline
 
10722
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10723
    _bz_uitrunc<typename P_expr1::T_numtype> > >
 
10724
uitrunc(_bz_VecExpr<P_expr1> d1)
 
10725
{
 
10726
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
10727
        _bz_uitrunc<typename P_expr1::T_numtype> > T_expr;
 
10728
 
 
10729
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10730
}
 
10731
 
 
10732
template<class P_numtype1>
 
10733
inline
 
10734
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10735
    _bz_uitrunc<P_numtype1> > >
 
10736
uitrunc(const VectorPick<P_numtype1>& d1)
 
10737
{
 
10738
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
10739
        _bz_uitrunc<P_numtype1> > T_expr;
 
10740
 
 
10741
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10742
}
 
10743
 
 
10744
 
 
10745
inline
 
10746
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
10747
    _bz_uitrunc<int> > >
 
10748
uitrunc(Range d1)
 
10749
{
 
10750
    typedef _bz_VecExprUnaryOp<Range,
 
10751
        _bz_uitrunc<int> > T_expr;
 
10752
 
 
10753
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
10754
}
 
10755
 
 
10756
template<class P_numtype1, int N_length1>
 
10757
inline
 
10758
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10759
    _bz_uitrunc<P_numtype1> > >
 
10760
uitrunc(const TinyVector<P_numtype1, N_length1>& d1)
 
10761
{
 
10762
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
10763
        _bz_uitrunc<P_numtype1> > T_expr;
 
10764
 
 
10765
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
10766
}
 
10767
 
 
10768
#endif
 
10769
 
 
10770
/****************************************************************************
 
10771
 * unordered
 
10772
 ****************************************************************************/
 
10773
 
 
10774
#ifdef BZ_HAVE_SYSTEM_V_MATH
 
10775
template<class P_numtype1, class P_numtype2>
 
10776
inline
 
10777
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
10778
    _bz_unordered<P_numtype1,P_numtype2> > >
 
10779
unordered(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
10780
{
 
10781
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
10782
        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
 
10783
 
 
10784
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
10785
}
 
10786
 
 
10787
template<class P_numtype1, class P_expr2>
 
10788
inline
 
10789
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
10790
    _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > >
 
10791
unordered(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
10792
{
 
10793
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
10794
        _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
10795
 
 
10796
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
10797
}
 
10798
 
 
10799
template<class P_numtype1, class P_numtype2>
 
10800
inline
 
10801
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
10802
    _bz_unordered<P_numtype1,P_numtype2> > >
 
10803
unordered(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
10804
{
 
10805
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
10806
        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
 
10807
 
 
10808
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
10809
}
 
10810
 
 
10811
template<class P_numtype1>
 
10812
inline
 
10813
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
10814
    _bz_unordered<P_numtype1,int> > >
 
10815
unordered(const Vector<P_numtype1>& d1, Range d2)
 
10816
{
 
10817
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
 
10818
        _bz_unordered<P_numtype1,int> > T_expr;
 
10819
 
 
10820
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
10821
}
 
10822
 
 
10823
template<class P_numtype1, class P_numtype2, int N_length2>
 
10824
inline
 
10825
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10826
    _bz_unordered<P_numtype1,P_numtype2> > >
 
10827
unordered(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
10828
{
 
10829
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10830
        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
 
10831
 
 
10832
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
10833
}
 
10834
 
 
10835
template<class P_numtype1>
 
10836
inline
 
10837
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
10838
    _bz_unordered<P_numtype1,int> > >
 
10839
unordered(const Vector<P_numtype1>& d1, int d2)
 
10840
{
 
10841
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
10842
        _bz_unordered<P_numtype1,int> > T_expr;
 
10843
 
 
10844
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
10845
}
 
10846
 
 
10847
template<class P_numtype1>
 
10848
inline
 
10849
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
10850
    _bz_unordered<P_numtype1,float> > >
 
10851
unordered(const Vector<P_numtype1>& d1, float d2)
 
10852
{
 
10853
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
10854
        _bz_unordered<P_numtype1,float> > T_expr;
 
10855
 
 
10856
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
10857
}
 
10858
 
 
10859
template<class P_numtype1>
 
10860
inline
 
10861
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
10862
    _bz_unordered<P_numtype1,double> > >
 
10863
unordered(const Vector<P_numtype1>& d1, double d2)
 
10864
{
 
10865
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
10866
        _bz_unordered<P_numtype1,double> > T_expr;
 
10867
 
 
10868
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
10869
}
 
10870
 
 
10871
template<class P_numtype1>
 
10872
inline
 
10873
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
10874
    _bz_unordered<P_numtype1,long double> > >
 
10875
unordered(const Vector<P_numtype1>& d1, long double d2)
 
10876
{
 
10877
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
10878
        _bz_unordered<P_numtype1,long double> > T_expr;
 
10879
 
 
10880
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
10881
}
 
10882
 
 
10883
template<class P_numtype1, class T2>
 
10884
inline
 
10885
_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
10886
    _bz_unordered<P_numtype1,complex<T2> > > >
 
10887
unordered(const Vector<P_numtype1>& d1, complex<T2> d2)
 
10888
{
 
10889
    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
10890
        _bz_unordered<P_numtype1,complex<T2> > > T_expr;
 
10891
 
 
10892
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
10893
}
 
10894
 
 
10895
template<class P_expr1, class P_numtype2>
 
10896
inline
 
10897
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
10898
    _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > >
 
10899
unordered(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
 
10900
{
 
10901
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
 
10902
        _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
10903
 
 
10904
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
10905
}
 
10906
 
 
10907
template<class P_expr1, class P_expr2>
 
10908
inline
 
10909
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
10910
    _bz_unordered<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
 
10911
unordered(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
 
10912
{
 
10913
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
 
10914
        _bz_unordered<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
 
10915
 
 
10916
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
10917
}
 
10918
 
 
10919
template<class P_expr1, class P_numtype2>
 
10920
inline
 
10921
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
10922
    _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > >
 
10923
unordered(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
 
10924
{
 
10925
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
 
10926
        _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
10927
 
 
10928
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
10929
}
 
10930
 
 
10931
template<class P_expr1>
 
10932
inline
 
10933
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
10934
    _bz_unordered<typename P_expr1::T_numtype,int> > >
 
10935
unordered(_bz_VecExpr<P_expr1> d1, Range d2)
 
10936
{
 
10937
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
 
10938
        _bz_unordered<typename P_expr1::T_numtype,int> > T_expr;
 
10939
 
 
10940
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
10941
}
 
10942
 
 
10943
template<class P_expr1, class P_numtype2, int N_length2>
 
10944
inline
 
10945
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10946
    _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > >
 
10947
unordered(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
10948
{
 
10949
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
10950
        _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > T_expr;
 
10951
 
 
10952
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
10953
}
 
10954
 
 
10955
template<class P_expr1>
 
10956
inline
 
10957
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
10958
    _bz_unordered<typename P_expr1::T_numtype,int> > >
 
10959
unordered(_bz_VecExpr<P_expr1> d1, int d2)
 
10960
{
 
10961
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
 
10962
        _bz_unordered<typename P_expr1::T_numtype,int> > T_expr;
 
10963
 
 
10964
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
10965
}
 
10966
 
 
10967
template<class P_expr1>
 
10968
inline
 
10969
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
10970
    _bz_unordered<typename P_expr1::T_numtype,float> > >
 
10971
unordered(_bz_VecExpr<P_expr1> d1, float d2)
 
10972
{
 
10973
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
 
10974
        _bz_unordered<typename P_expr1::T_numtype,float> > T_expr;
 
10975
 
 
10976
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
10977
}
 
10978
 
 
10979
template<class P_expr1>
 
10980
inline
 
10981
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
10982
    _bz_unordered<typename P_expr1::T_numtype,double> > >
 
10983
unordered(_bz_VecExpr<P_expr1> d1, double d2)
 
10984
{
 
10985
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
 
10986
        _bz_unordered<typename P_expr1::T_numtype,double> > T_expr;
 
10987
 
 
10988
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
10989
}
 
10990
 
 
10991
template<class P_expr1>
 
10992
inline
 
10993
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
10994
    _bz_unordered<typename P_expr1::T_numtype,long double> > >
 
10995
unordered(_bz_VecExpr<P_expr1> d1, long double d2)
 
10996
{
 
10997
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
 
10998
        _bz_unordered<typename P_expr1::T_numtype,long double> > T_expr;
 
10999
 
 
11000
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
11001
}
 
11002
 
 
11003
template<class P_expr1, class T2>
 
11004
inline
 
11005
_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
11006
    _bz_unordered<typename P_expr1::T_numtype,complex<T2> > > >
 
11007
unordered(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
 
11008
{
 
11009
    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
 
11010
        _bz_unordered<typename P_expr1::T_numtype,complex<T2> > > T_expr;
 
11011
 
 
11012
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
11013
}
 
11014
 
 
11015
template<class P_numtype1, class P_numtype2>
 
11016
inline
 
11017
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
11018
    _bz_unordered<P_numtype1,P_numtype2> > >
 
11019
unordered(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
 
11020
{
 
11021
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
 
11022
        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
 
11023
 
 
11024
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
11025
}
 
11026
 
 
11027
template<class P_numtype1, class P_expr2>
 
11028
inline
 
11029
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
11030
    _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > >
 
11031
unordered(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
 
11032
{
 
11033
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
 
11034
        _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
11035
 
 
11036
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
11037
}
 
11038
 
 
11039
template<class P_numtype1, class P_numtype2>
 
11040
inline
 
11041
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
11042
    _bz_unordered<P_numtype1,P_numtype2> > >
 
11043
unordered(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
 
11044
{
 
11045
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
 
11046
        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
 
11047
 
 
11048
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
11049
}
 
11050
 
 
11051
template<class P_numtype1>
 
11052
inline
 
11053
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
11054
    _bz_unordered<P_numtype1,int> > >
 
11055
unordered(const VectorPick<P_numtype1>& d1, Range d2)
 
11056
{
 
11057
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
 
11058
        _bz_unordered<P_numtype1,int> > T_expr;
 
11059
 
 
11060
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
11061
}
 
11062
 
 
11063
template<class P_numtype1, class P_numtype2, int N_length2>
 
11064
inline
 
11065
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11066
    _bz_unordered<P_numtype1,P_numtype2> > >
 
11067
unordered(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
11068
{
 
11069
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11070
        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
 
11071
 
 
11072
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
11073
}
 
11074
 
 
11075
template<class P_numtype1>
 
11076
inline
 
11077
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
11078
    _bz_unordered<P_numtype1,int> > >
 
11079
unordered(const VectorPick<P_numtype1>& d1, int d2)
 
11080
{
 
11081
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
 
11082
        _bz_unordered<P_numtype1,int> > T_expr;
 
11083
 
 
11084
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
11085
}
 
11086
 
 
11087
template<class P_numtype1>
 
11088
inline
 
11089
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
11090
    _bz_unordered<P_numtype1,float> > >
 
11091
unordered(const VectorPick<P_numtype1>& d1, float d2)
 
11092
{
 
11093
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
 
11094
        _bz_unordered<P_numtype1,float> > T_expr;
 
11095
 
 
11096
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
11097
}
 
11098
 
 
11099
template<class P_numtype1>
 
11100
inline
 
11101
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
11102
    _bz_unordered<P_numtype1,double> > >
 
11103
unordered(const VectorPick<P_numtype1>& d1, double d2)
 
11104
{
 
11105
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
 
11106
        _bz_unordered<P_numtype1,double> > T_expr;
 
11107
 
 
11108
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
11109
}
 
11110
 
 
11111
template<class P_numtype1>
 
11112
inline
 
11113
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
11114
    _bz_unordered<P_numtype1,long double> > >
 
11115
unordered(const VectorPick<P_numtype1>& d1, long double d2)
 
11116
{
 
11117
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
 
11118
        _bz_unordered<P_numtype1,long double> > T_expr;
 
11119
 
 
11120
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
11121
}
 
11122
 
 
11123
template<class P_numtype1, class T2>
 
11124
inline
 
11125
_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
11126
    _bz_unordered<P_numtype1,complex<T2> > > >
 
11127
unordered(const VectorPick<P_numtype1>& d1, complex<T2> d2)
 
11128
{
 
11129
    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
 
11130
        _bz_unordered<P_numtype1,complex<T2> > > T_expr;
 
11131
 
 
11132
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
11133
}
 
11134
 
 
11135
template<class P_numtype2>
 
11136
inline
 
11137
_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
11138
    _bz_unordered<int,P_numtype2> > >
 
11139
unordered(Range d1, const Vector<P_numtype2>& d2)
 
11140
{
 
11141
    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
 
11142
        _bz_unordered<int,P_numtype2> > T_expr;
 
11143
 
 
11144
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
11145
}
 
11146
 
 
11147
template<class P_expr2>
 
11148
inline
 
11149
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
11150
    _bz_unordered<int,typename P_expr2::T_numtype> > >
 
11151
unordered(Range d1, _bz_VecExpr<P_expr2> d2)
 
11152
{
 
11153
    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
 
11154
        _bz_unordered<int,typename P_expr2::T_numtype> > T_expr;
 
11155
 
 
11156
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
11157
}
 
11158
 
 
11159
template<class P_numtype2>
 
11160
inline
 
11161
_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
11162
    _bz_unordered<int,P_numtype2> > >
 
11163
unordered(Range d1, const VectorPick<P_numtype2>& d2)
 
11164
{
 
11165
    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
 
11166
        _bz_unordered<int,P_numtype2> > T_expr;
 
11167
 
 
11168
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
11169
}
 
11170
 
 
11171
 
 
11172
inline
 
11173
_bz_VecExpr<_bz_VecExprOp<Range, Range,
 
11174
    _bz_unordered<int,int> > >
 
11175
unordered(Range d1, Range d2)
 
11176
{
 
11177
    typedef _bz_VecExprOp<Range, Range,
 
11178
        _bz_unordered<int,int> > T_expr;
 
11179
 
 
11180
    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
 
11181
}
 
11182
 
 
11183
template<class P_numtype2, int N_length2>
 
11184
inline
 
11185
_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
11186
    _bz_unordered<int,P_numtype2> > >
 
11187
unordered(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
 
11188
{
 
11189
    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
 
11190
        _bz_unordered<int,P_numtype2> > T_expr;
 
11191
 
 
11192
    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
 
11193
}
 
11194
 
 
11195
 
 
11196
inline
 
11197
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
11198
    _bz_unordered<int,int> > >
 
11199
unordered(Range d1, int d2)
 
11200
{
 
11201
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
 
11202
        _bz_unordered<int,int> > T_expr;
 
11203
 
 
11204
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
 
11205
}
 
11206
 
 
11207
 
 
11208
inline
 
11209
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
11210
    _bz_unordered<int,float> > >
 
11211
unordered(Range d1, float d2)
 
11212
{
 
11213
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
 
11214
        _bz_unordered<int,float> > T_expr;
 
11215
 
 
11216
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
 
11217
}
 
11218
 
 
11219
 
 
11220
inline
 
11221
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
11222
    _bz_unordered<int,double> > >
 
11223
unordered(Range d1, double d2)
 
11224
{
 
11225
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
 
11226
        _bz_unordered<int,double> > T_expr;
 
11227
 
 
11228
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
 
11229
}
 
11230
 
 
11231
 
 
11232
inline
 
11233
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
11234
    _bz_unordered<int,long double> > >
 
11235
unordered(Range d1, long double d2)
 
11236
{
 
11237
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
 
11238
        _bz_unordered<int,long double> > T_expr;
 
11239
 
 
11240
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
 
11241
}
 
11242
 
 
11243
template<class T2>
 
11244
inline
 
11245
_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
11246
    _bz_unordered<int,complex<T2> > > >
 
11247
unordered(Range d1, complex<T2> d2)
 
11248
{
 
11249
    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
 
11250
        _bz_unordered<int,complex<T2> > > T_expr;
 
11251
 
 
11252
    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
 
11253
}
 
11254
 
 
11255
template<class P_numtype1, int N_length1, class P_numtype2>
 
11256
inline
 
11257
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
11258
    _bz_unordered<P_numtype1,P_numtype2> > >
 
11259
unordered(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
 
11260
{
 
11261
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
 
11262
        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
 
11263
 
 
11264
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
11265
}
 
11266
 
 
11267
template<class P_numtype1, int N_length1, class P_expr2>
 
11268
inline
 
11269
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
11270
    _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > >
 
11271
unordered(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
 
11272
{
 
11273
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
 
11274
        _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > T_expr;
 
11275
 
 
11276
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
11277
}
 
11278
 
 
11279
template<class P_numtype1, int N_length1, class P_numtype2>
 
11280
inline
 
11281
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
11282
    _bz_unordered<P_numtype1,P_numtype2> > >
 
11283
unordered(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
 
11284
{
 
11285
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
 
11286
        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
 
11287
 
 
11288
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
11289
}
 
11290
 
 
11291
template<class P_numtype1, int N_length1>
 
11292
inline
 
11293
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
11294
    _bz_unordered<P_numtype1,int> > >
 
11295
unordered(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
 
11296
{
 
11297
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
 
11298
        _bz_unordered<P_numtype1,int> > T_expr;
 
11299
 
 
11300
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
 
11301
}
 
11302
 
 
11303
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
 
11304
inline
 
11305
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11306
    _bz_unordered<P_numtype1,P_numtype2> > >
 
11307
unordered(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
 
11308
{
 
11309
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11310
        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
 
11311
 
 
11312
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
 
11313
}
 
11314
 
 
11315
template<class P_numtype1, int N_length1>
 
11316
inline
 
11317
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
11318
    _bz_unordered<P_numtype1,int> > >
 
11319
unordered(const TinyVector<P_numtype1, N_length1>& d1, int d2)
 
11320
{
 
11321
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
 
11322
        _bz_unordered<P_numtype1,int> > T_expr;
 
11323
 
 
11324
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
 
11325
}
 
11326
 
 
11327
template<class P_numtype1, int N_length1>
 
11328
inline
 
11329
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
11330
    _bz_unordered<P_numtype1,float> > >
 
11331
unordered(const TinyVector<P_numtype1, N_length1>& d1, float d2)
 
11332
{
 
11333
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
 
11334
        _bz_unordered<P_numtype1,float> > T_expr;
 
11335
 
 
11336
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
 
11337
}
 
11338
 
 
11339
template<class P_numtype1, int N_length1>
 
11340
inline
 
11341
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
11342
    _bz_unordered<P_numtype1,double> > >
 
11343
unordered(const TinyVector<P_numtype1, N_length1>& d1, double d2)
 
11344
{
 
11345
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
 
11346
        _bz_unordered<P_numtype1,double> > T_expr;
 
11347
 
 
11348
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
 
11349
}
 
11350
 
 
11351
template<class P_numtype1, int N_length1>
 
11352
inline
 
11353
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
11354
    _bz_unordered<P_numtype1,long double> > >
 
11355
unordered(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
 
11356
{
 
11357
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
 
11358
        _bz_unordered<P_numtype1,long double> > T_expr;
 
11359
 
 
11360
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
 
11361
}
 
11362
 
 
11363
template<class P_numtype1, int N_length1, class T2>
 
11364
inline
 
11365
_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
11366
    _bz_unordered<P_numtype1,complex<T2> > > >
 
11367
unordered(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
 
11368
{
 
11369
    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
 
11370
        _bz_unordered<P_numtype1,complex<T2> > > T_expr;
 
11371
 
 
11372
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
 
11373
}
 
11374
 
 
11375
template<class P_numtype2>
 
11376
inline
 
11377
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
11378
    _bz_unordered<int,P_numtype2> > >
 
11379
unordered(int d1, const Vector<P_numtype2>& d2)
 
11380
{
 
11381
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
 
11382
        _bz_unordered<int,P_numtype2> > T_expr;
 
11383
 
 
11384
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
11385
}
 
11386
 
 
11387
template<class P_expr2>
 
11388
inline
 
11389
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
11390
    _bz_unordered<int,typename P_expr2::T_numtype> > >
 
11391
unordered(int d1, _bz_VecExpr<P_expr2> d2)
 
11392
{
 
11393
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
 
11394
        _bz_unordered<int,typename P_expr2::T_numtype> > T_expr;
 
11395
 
 
11396
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
11397
}
 
11398
 
 
11399
template<class P_numtype2>
 
11400
inline
 
11401
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
11402
    _bz_unordered<int,P_numtype2> > >
 
11403
unordered(int d1, const VectorPick<P_numtype2>& d2)
 
11404
{
 
11405
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
 
11406
        _bz_unordered<int,P_numtype2> > T_expr;
 
11407
 
 
11408
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
11409
}
 
11410
 
 
11411
 
 
11412
inline
 
11413
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
11414
    _bz_unordered<int,int> > >
 
11415
unordered(int d1, Range d2)
 
11416
{
 
11417
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
 
11418
        _bz_unordered<int,int> > T_expr;
 
11419
 
 
11420
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
 
11421
}
 
11422
 
 
11423
template<class P_numtype2, int N_length2>
 
11424
inline
 
11425
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11426
    _bz_unordered<int,P_numtype2> > >
 
11427
unordered(int d1, const TinyVector<P_numtype2, N_length2>& d2)
 
11428
{
 
11429
    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11430
        _bz_unordered<int,P_numtype2> > T_expr;
 
11431
 
 
11432
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
 
11433
}
 
11434
 
 
11435
template<class P_numtype2>
 
11436
inline
 
11437
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
11438
    _bz_unordered<float,P_numtype2> > >
 
11439
unordered(float d1, const Vector<P_numtype2>& d2)
 
11440
{
 
11441
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
 
11442
        _bz_unordered<float,P_numtype2> > T_expr;
 
11443
 
 
11444
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
11445
}
 
11446
 
 
11447
template<class P_expr2>
 
11448
inline
 
11449
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
11450
    _bz_unordered<float,typename P_expr2::T_numtype> > >
 
11451
unordered(float d1, _bz_VecExpr<P_expr2> d2)
 
11452
{
 
11453
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
 
11454
        _bz_unordered<float,typename P_expr2::T_numtype> > T_expr;
 
11455
 
 
11456
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
11457
}
 
11458
 
 
11459
template<class P_numtype2>
 
11460
inline
 
11461
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
11462
    _bz_unordered<float,P_numtype2> > >
 
11463
unordered(float d1, const VectorPick<P_numtype2>& d2)
 
11464
{
 
11465
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
 
11466
        _bz_unordered<float,P_numtype2> > T_expr;
 
11467
 
 
11468
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
11469
}
 
11470
 
 
11471
 
 
11472
inline
 
11473
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
11474
    _bz_unordered<float,int> > >
 
11475
unordered(float d1, Range d2)
 
11476
{
 
11477
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
 
11478
        _bz_unordered<float,int> > T_expr;
 
11479
 
 
11480
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
 
11481
}
 
11482
 
 
11483
template<class P_numtype2, int N_length2>
 
11484
inline
 
11485
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11486
    _bz_unordered<float,P_numtype2> > >
 
11487
unordered(float d1, const TinyVector<P_numtype2, N_length2>& d2)
 
11488
{
 
11489
    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11490
        _bz_unordered<float,P_numtype2> > T_expr;
 
11491
 
 
11492
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
 
11493
}
 
11494
 
 
11495
template<class P_numtype2>
 
11496
inline
 
11497
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
11498
    _bz_unordered<double,P_numtype2> > >
 
11499
unordered(double d1, const Vector<P_numtype2>& d2)
 
11500
{
 
11501
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
 
11502
        _bz_unordered<double,P_numtype2> > T_expr;
 
11503
 
 
11504
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
11505
}
 
11506
 
 
11507
template<class P_expr2>
 
11508
inline
 
11509
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
11510
    _bz_unordered<double,typename P_expr2::T_numtype> > >
 
11511
unordered(double d1, _bz_VecExpr<P_expr2> d2)
 
11512
{
 
11513
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
 
11514
        _bz_unordered<double,typename P_expr2::T_numtype> > T_expr;
 
11515
 
 
11516
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
11517
}
 
11518
 
 
11519
template<class P_numtype2>
 
11520
inline
 
11521
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
11522
    _bz_unordered<double,P_numtype2> > >
 
11523
unordered(double d1, const VectorPick<P_numtype2>& d2)
 
11524
{
 
11525
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
 
11526
        _bz_unordered<double,P_numtype2> > T_expr;
 
11527
 
 
11528
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
11529
}
 
11530
 
 
11531
 
 
11532
inline
 
11533
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
11534
    _bz_unordered<double,int> > >
 
11535
unordered(double d1, Range d2)
 
11536
{
 
11537
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
 
11538
        _bz_unordered<double,int> > T_expr;
 
11539
 
 
11540
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
 
11541
}
 
11542
 
 
11543
template<class P_numtype2, int N_length2>
 
11544
inline
 
11545
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11546
    _bz_unordered<double,P_numtype2> > >
 
11547
unordered(double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
11548
{
 
11549
    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11550
        _bz_unordered<double,P_numtype2> > T_expr;
 
11551
 
 
11552
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
 
11553
}
 
11554
 
 
11555
template<class P_numtype2>
 
11556
inline
 
11557
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
11558
    _bz_unordered<long double,P_numtype2> > >
 
11559
unordered(long double d1, const Vector<P_numtype2>& d2)
 
11560
{
 
11561
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
 
11562
        _bz_unordered<long double,P_numtype2> > T_expr;
 
11563
 
 
11564
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
11565
}
 
11566
 
 
11567
template<class P_expr2>
 
11568
inline
 
11569
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
11570
    _bz_unordered<long double,typename P_expr2::T_numtype> > >
 
11571
unordered(long double d1, _bz_VecExpr<P_expr2> d2)
 
11572
{
 
11573
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
 
11574
        _bz_unordered<long double,typename P_expr2::T_numtype> > T_expr;
 
11575
 
 
11576
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
11577
}
 
11578
 
 
11579
template<class P_numtype2>
 
11580
inline
 
11581
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
11582
    _bz_unordered<long double,P_numtype2> > >
 
11583
unordered(long double d1, const VectorPick<P_numtype2>& d2)
 
11584
{
 
11585
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
 
11586
        _bz_unordered<long double,P_numtype2> > T_expr;
 
11587
 
 
11588
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
11589
}
 
11590
 
 
11591
 
 
11592
inline
 
11593
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
11594
    _bz_unordered<long double,int> > >
 
11595
unordered(long double d1, Range d2)
 
11596
{
 
11597
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
 
11598
        _bz_unordered<long double,int> > T_expr;
 
11599
 
 
11600
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
 
11601
}
 
11602
 
 
11603
template<class P_numtype2, int N_length2>
 
11604
inline
 
11605
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11606
    _bz_unordered<long double,P_numtype2> > >
 
11607
unordered(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
 
11608
{
 
11609
    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
 
11610
        _bz_unordered<long double,P_numtype2> > T_expr;
 
11611
 
 
11612
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
 
11613
}
 
11614
 
 
11615
template<class T1, class P_numtype2>
 
11616
inline
 
11617
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
11618
    _bz_unordered<complex<T1> ,P_numtype2> > >
 
11619
unordered(complex<T1> d1, const Vector<P_numtype2>& d2)
 
11620
{
 
11621
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
 
11622
        _bz_unordered<complex<T1> ,P_numtype2> > T_expr;
 
11623
 
 
11624
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
11625
}
 
11626
 
 
11627
template<class T1, class P_expr2>
 
11628
inline
 
11629
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
11630
    _bz_unordered<complex<T1> ,typename P_expr2::T_numtype> > >
 
11631
unordered(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
 
11632
{
 
11633
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
 
11634
        _bz_unordered<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
 
11635
 
 
11636
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
11637
}
 
11638
 
 
11639
template<class T1, class P_numtype2>
 
11640
inline
 
11641
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
11642
    _bz_unordered<complex<T1> ,P_numtype2> > >
 
11643
unordered(complex<T1> d1, const VectorPick<P_numtype2>& d2)
 
11644
{
 
11645
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
 
11646
        _bz_unordered<complex<T1> ,P_numtype2> > T_expr;
 
11647
 
 
11648
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
11649
}
 
11650
 
 
11651
template<class T1>
 
11652
inline
 
11653
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
11654
    _bz_unordered<complex<T1> ,int> > >
 
11655
unordered(complex<T1> d1, Range d2)
 
11656
{
 
11657
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
 
11658
        _bz_unordered<complex<T1> ,int> > T_expr;
 
11659
 
 
11660
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
 
11661
}
 
11662
 
 
11663
template<class T1, class P_numtype2, int N_length2>
 
11664
inline
 
11665
_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
11666
    _bz_unordered<complex<T1> ,P_numtype2> > >
 
11667
unordered(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
 
11668
{
 
11669
    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
 
11670
        _bz_unordered<complex<T1> ,P_numtype2> > T_expr;
 
11671
 
 
11672
    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
 
11673
}
 
11674
 
 
11675
#endif
 
11676
 
 
11677
/****************************************************************************
 
11678
 * y0
 
11679
 ****************************************************************************/
 
11680
 
 
11681
#ifdef BZ_HAVE_IEEE_MATH
 
11682
template<class P_numtype1>
 
11683
inline
 
11684
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
11685
    _bz_y0<P_numtype1> > >
 
11686
y0(const Vector<P_numtype1>& d1)
 
11687
{
 
11688
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
11689
        _bz_y0<P_numtype1> > T_expr;
 
11690
 
 
11691
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
11692
}
 
11693
 
 
11694
template<class P_expr1>
 
11695
inline
 
11696
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
11697
    _bz_y0<typename P_expr1::T_numtype> > >
 
11698
y0(_bz_VecExpr<P_expr1> d1)
 
11699
{
 
11700
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
11701
        _bz_y0<typename P_expr1::T_numtype> > T_expr;
 
11702
 
 
11703
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
11704
}
 
11705
 
 
11706
template<class P_numtype1>
 
11707
inline
 
11708
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
11709
    _bz_y0<P_numtype1> > >
 
11710
y0(const VectorPick<P_numtype1>& d1)
 
11711
{
 
11712
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
11713
        _bz_y0<P_numtype1> > T_expr;
 
11714
 
 
11715
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
11716
}
 
11717
 
 
11718
 
 
11719
inline
 
11720
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
11721
    _bz_y0<int> > >
 
11722
y0(Range d1)
 
11723
{
 
11724
    typedef _bz_VecExprUnaryOp<Range,
 
11725
        _bz_y0<int> > T_expr;
 
11726
 
 
11727
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
11728
}
 
11729
 
 
11730
template<class P_numtype1, int N_length1>
 
11731
inline
 
11732
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
11733
    _bz_y0<P_numtype1> > >
 
11734
y0(const TinyVector<P_numtype1, N_length1>& d1)
 
11735
{
 
11736
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
11737
        _bz_y0<P_numtype1> > T_expr;
 
11738
 
 
11739
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
11740
}
 
11741
 
 
11742
#endif
 
11743
 
 
11744
/****************************************************************************
 
11745
 * y1
 
11746
 ****************************************************************************/
 
11747
 
 
11748
#ifdef BZ_HAVE_IEEE_MATH
 
11749
template<class P_numtype1>
 
11750
inline
 
11751
_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
11752
    _bz_y1<P_numtype1> > >
 
11753
y1(const Vector<P_numtype1>& d1)
 
11754
{
 
11755
    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
 
11756
        _bz_y1<P_numtype1> > T_expr;
 
11757
 
 
11758
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
11759
}
 
11760
 
 
11761
template<class P_expr1>
 
11762
inline
 
11763
_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
11764
    _bz_y1<typename P_expr1::T_numtype> > >
 
11765
y1(_bz_VecExpr<P_expr1> d1)
 
11766
{
 
11767
    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
 
11768
        _bz_y1<typename P_expr1::T_numtype> > T_expr;
 
11769
 
 
11770
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
11771
}
 
11772
 
 
11773
template<class P_numtype1>
 
11774
inline
 
11775
_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
11776
    _bz_y1<P_numtype1> > >
 
11777
y1(const VectorPick<P_numtype1>& d1)
 
11778
{
 
11779
    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
 
11780
        _bz_y1<P_numtype1> > T_expr;
 
11781
 
 
11782
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
11783
}
 
11784
 
 
11785
 
 
11786
inline
 
11787
_bz_VecExpr<_bz_VecExprUnaryOp<Range,
 
11788
    _bz_y1<int> > >
 
11789
y1(Range d1)
 
11790
{
 
11791
    typedef _bz_VecExprUnaryOp<Range,
 
11792
        _bz_y1<int> > T_expr;
 
11793
 
 
11794
    return _bz_VecExpr<T_expr>(T_expr(d1));
 
11795
}
 
11796
 
 
11797
template<class P_numtype1, int N_length1>
 
11798
inline
 
11799
_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
11800
    _bz_y1<P_numtype1> > >
 
11801
y1(const TinyVector<P_numtype1, N_length1>& d1)
 
11802
{
 
11803
    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
 
11804
        _bz_y1<P_numtype1> > T_expr;
 
11805
 
 
11806
    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
 
11807
}
 
11808
 
 
11809
#endif
 
11810
 
 
11811
BZ_NAMESPACE_END
 
11812
 
 
11813
#endif