« back to all changes in this revision
Viewing changes to blitz/vecwhere.cc
- browse files at revision 16
- compare with another revision
- download diff
- download tarball
- view history from revision 16
- Committer: Package Import Robot
- Author(s): Christophe Trophime
- Date: 2012-07-06 09:15:30 UTC
- mfrom: (11.1.5 sid)
- Revision ID: package-import@ubuntu.com-20120706091530-vzrb8zf0vpbf8tp9
Tags: 1:0.10-1
* New upstream release
Closes: #679407
* debian/rules:
- update for new release
- add override_dh_auto_test target
- regenerate configure and Makefile.am
* debian/control:
- add libtool, automake to BuildDepends
* debian/libblitz-doc.install
- modify path for html files
* remove uneeded patches
* add examples.patch
Closes: #679407
* debian/rules:
- update for new release
- add override_dh_auto_test target
- regenerate configure and Makefile.am
* debian/control:
- add libtool, automake to BuildDepends
* debian/libblitz-doc.install
- modify path for html files
* remove uneeded patches
* add examples.patch
- files added:
- .pc/.quilt_patches
- .pc/examples.patch
- .pc/examples.patch/examples
- files removed:
- .pc/01_gcc34_amd64.patch
- .pc/01_gcc34_amd64.patch/blitz
- .pc/01_gcc_43_missing_includes.patch
- .pc/01_gcc_43_missing_includes.patch/blitz
- .pc/30_fix_doxygen_install_target.patch
- .pc/30_fix_doxygen_install_target.patch/doc
- .pc/30_fix_doxygen_install_target.patch/doc/doxygen
- .pc/40_prevent_celetion_of_texi_files.patch
- .pc/40_prevent_celetion_of_texi_files.patch/doc
- .pc/40_prevent_celetion_of_texi_files.patch/doc/examples
- .pc/40_prevent_celetion_of_texi_files.patch/doc/stencils
- files modified:
- .pc/applied-patches
added
removed
blitz/vecwhere.cc
1
/***************************************************************************
2
* blitz/../vecwhere.cc where(X,Y,Z) function for vectors
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
// genvecwhere.cpp Oct 6 2005 15:58:49
26
27
#ifndef BZ_VECWHERE_CC
28
#define BZ_VECWHERE_CC
29
30
BZ_NAMESPACE(blitz)
31
32
// where(Vector<P_numtype1>, Vector<P_numtype2>, Vector<P_numtype3>)
33
template<class P_numtype1, class P_numtype2, class P_numtype3>
34
inline
35
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
36
VectorIterConst<P_numtype2>,
37
VectorIterConst<P_numtype3> > >
38
where(const Vector<P_numtype1>& d1,
39
const Vector<P_numtype2>& d2,
40
const Vector<P_numtype3>& d3)
41
{
42
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
43
VectorIterConst<P_numtype2>,
44
VectorIterConst<P_numtype3> > T_expr;
45
46
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
47
d2.beginFast(),
48
d3.beginFast()));
49
}
50
51
// where(Vector<P_numtype1>, Vector<P_numtype2>, _bz_VecExpr<P_expr3>)
52
template<class P_numtype1, class P_numtype2, class P_expr3>
53
inline
54
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
55
VectorIterConst<P_numtype2>,
56
_bz_VecExpr<P_expr3> > >
57
where(const Vector<P_numtype1>& d1,
58
const Vector<P_numtype2>& d2,
59
_bz_VecExpr<P_expr3> d3)
60
{
61
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
62
VectorIterConst<P_numtype2>,
63
_bz_VecExpr<P_expr3> > T_expr;
64
65
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
66
d2.beginFast(),
67
d3));
68
}
69
70
// where(Vector<P_numtype1>, Vector<P_numtype2>, VectorPick<P_numtype3>)
71
template<class P_numtype1, class P_numtype2, class P_numtype3>
72
inline
73
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
74
VectorIterConst<P_numtype2>,
75
VectorPickIterConst<P_numtype3> > >
76
where(const Vector<P_numtype1>& d1,
77
const Vector<P_numtype2>& d2,
78
const VectorPick<P_numtype3>& d3)
79
{
80
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
81
VectorIterConst<P_numtype2>,
82
VectorPickIterConst<P_numtype3> > T_expr;
83
84
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
85
d2.beginFast(),
86
d3.beginFast()));
87
}
88
89
// where(Vector<P_numtype1>, Vector<P_numtype2>, Range)
90
template<class P_numtype1, class P_numtype2>
91
inline
92
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
93
VectorIterConst<P_numtype2>,
94
Range > >
95
where(const Vector<P_numtype1>& d1,
96
const Vector<P_numtype2>& d2,
97
Range d3)
98
{
99
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
100
VectorIterConst<P_numtype2>,
101
Range > T_expr;
102
103
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
104
d2.beginFast(),
105
d3));
106
}
107
108
// where(Vector<P_numtype1>, Vector<P_numtype2>, TinyVector<P_numtype3, N_length3>)
109
template<class P_numtype1, class P_numtype2, class P_numtype3, int N_length3>
110
inline
111
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
112
VectorIterConst<P_numtype2>,
113
TinyVectorIterConst<P_numtype3, N_length3> > >
114
where(const Vector<P_numtype1>& d1,
115
const Vector<P_numtype2>& d2,
116
const TinyVector<P_numtype3, N_length3>& d3)
117
{
118
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
119
VectorIterConst<P_numtype2>,
120
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
121
122
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
123
d2.beginFast(),
124
d3.beginFast()));
125
}
126
127
// where(Vector<P_numtype1>, Vector<P_numtype2>, int)
128
template<class P_numtype1, class P_numtype2>
129
inline
130
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
131
VectorIterConst<P_numtype2>,
132
_bz_VecExprConstant<int> > >
133
where(const Vector<P_numtype1>& d1,
134
const Vector<P_numtype2>& d2,
135
int d3)
136
{
137
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
138
VectorIterConst<P_numtype2>,
139
_bz_VecExprConstant<int> > T_expr;
140
141
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
142
d2.beginFast(),
143
_bz_VecExprConstant<int>(d3)));
144
}
145
146
// where(Vector<P_numtype1>, Vector<P_numtype2>, float)
147
template<class P_numtype1, class P_numtype2>
148
inline
149
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
150
VectorIterConst<P_numtype2>,
151
_bz_VecExprConstant<float> > >
152
where(const Vector<P_numtype1>& d1,
153
const Vector<P_numtype2>& d2,
154
float d3)
155
{
156
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
157
VectorIterConst<P_numtype2>,
158
_bz_VecExprConstant<float> > T_expr;
159
160
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
161
d2.beginFast(),
162
_bz_VecExprConstant<float>(d3)));
163
}
164
165
// where(Vector<P_numtype1>, Vector<P_numtype2>, double)
166
template<class P_numtype1, class P_numtype2>
167
inline
168
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
169
VectorIterConst<P_numtype2>,
170
_bz_VecExprConstant<double> > >
171
where(const Vector<P_numtype1>& d1,
172
const Vector<P_numtype2>& d2,
173
double d3)
174
{
175
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
176
VectorIterConst<P_numtype2>,
177
_bz_VecExprConstant<double> > T_expr;
178
179
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
180
d2.beginFast(),
181
_bz_VecExprConstant<double>(d3)));
182
}
183
184
// where(Vector<P_numtype1>, Vector<P_numtype2>, long double)
185
template<class P_numtype1, class P_numtype2>
186
inline
187
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
188
VectorIterConst<P_numtype2>,
189
_bz_VecExprConstant<long double> > >
190
where(const Vector<P_numtype1>& d1,
191
const Vector<P_numtype2>& d2,
192
long double d3)
193
{
194
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
195
VectorIterConst<P_numtype2>,
196
_bz_VecExprConstant<long double> > T_expr;
197
198
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
199
d2.beginFast(),
200
_bz_VecExprConstant<long double>(d3)));
201
}
202
203
// where(Vector<P_numtype1>, Vector<P_numtype2>, complex<T3>)
204
#ifdef BZ_HAVE_COMPLEX
205
template<class P_numtype1, class P_numtype2, class T3>
206
inline
207
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
208
VectorIterConst<P_numtype2>,
209
_bz_VecExprConstant<complex<T3> > > >
210
where(const Vector<P_numtype1>& d1,
211
const Vector<P_numtype2>& d2,
212
complex<T3> d3)
213
{
214
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
215
VectorIterConst<P_numtype2>,
216
_bz_VecExprConstant<complex<T3> > > T_expr;
217
218
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
219
d2.beginFast(),
220
_bz_VecExprConstant<complex<T3> > (d3)));
221
}
222
#endif // BZ_HAVE_COMPLEX
223
224
// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, Vector<P_numtype3>)
225
template<class P_numtype1, class P_expr2, class P_numtype3>
226
inline
227
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
228
_bz_VecExpr<P_expr2>,
229
VectorIterConst<P_numtype3> > >
230
where(const Vector<P_numtype1>& d1,
231
_bz_VecExpr<P_expr2> d2,
232
const Vector<P_numtype3>& d3)
233
{
234
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
235
_bz_VecExpr<P_expr2>,
236
VectorIterConst<P_numtype3> > T_expr;
237
238
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
239
d2,
240
d3.beginFast()));
241
}
242
243
// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, _bz_VecExpr<P_expr3>)
244
template<class P_numtype1, class P_expr2, class P_expr3>
245
inline
246
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
247
_bz_VecExpr<P_expr2>,
248
_bz_VecExpr<P_expr3> > >
249
where(const Vector<P_numtype1>& d1,
250
_bz_VecExpr<P_expr2> d2,
251
_bz_VecExpr<P_expr3> d3)
252
{
253
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
254
_bz_VecExpr<P_expr2>,
255
_bz_VecExpr<P_expr3> > T_expr;
256
257
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
258
d2,
259
d3));
260
}
261
262
// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, VectorPick<P_numtype3>)
263
template<class P_numtype1, class P_expr2, class P_numtype3>
264
inline
265
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
266
_bz_VecExpr<P_expr2>,
267
VectorPickIterConst<P_numtype3> > >
268
where(const Vector<P_numtype1>& d1,
269
_bz_VecExpr<P_expr2> d2,
270
const VectorPick<P_numtype3>& d3)
271
{
272
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
273
_bz_VecExpr<P_expr2>,
274
VectorPickIterConst<P_numtype3> > T_expr;
275
276
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
277
d2,
278
d3.beginFast()));
279
}
280
281
// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, Range)
282
template<class P_numtype1, class P_expr2>
283
inline
284
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
285
_bz_VecExpr<P_expr2>,
286
Range > >
287
where(const Vector<P_numtype1>& d1,
288
_bz_VecExpr<P_expr2> d2,
289
Range d3)
290
{
291
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
292
_bz_VecExpr<P_expr2>,
293
Range > T_expr;
294
295
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
296
d2,
297
d3));
298
}
299
300
// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, TinyVector<P_numtype3, N_length3>)
301
template<class P_numtype1, class P_expr2, class P_numtype3, int N_length3>
302
inline
303
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
304
_bz_VecExpr<P_expr2>,
305
TinyVectorIterConst<P_numtype3, N_length3> > >
306
where(const Vector<P_numtype1>& d1,
307
_bz_VecExpr<P_expr2> d2,
308
const TinyVector<P_numtype3, N_length3>& d3)
309
{
310
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
311
_bz_VecExpr<P_expr2>,
312
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
313
314
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
315
d2,
316
d3.beginFast()));
317
}
318
319
// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, int)
320
template<class P_numtype1, class P_expr2>
321
inline
322
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
323
_bz_VecExpr<P_expr2>,
324
_bz_VecExprConstant<int> > >
325
where(const Vector<P_numtype1>& d1,
326
_bz_VecExpr<P_expr2> d2,
327
int d3)
328
{
329
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
330
_bz_VecExpr<P_expr2>,
331
_bz_VecExprConstant<int> > T_expr;
332
333
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
334
d2,
335
_bz_VecExprConstant<int>(d3)));
336
}
337
338
// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, float)
339
template<class P_numtype1, class P_expr2>
340
inline
341
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
342
_bz_VecExpr<P_expr2>,
343
_bz_VecExprConstant<float> > >
344
where(const Vector<P_numtype1>& d1,
345
_bz_VecExpr<P_expr2> d2,
346
float d3)
347
{
348
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
349
_bz_VecExpr<P_expr2>,
350
_bz_VecExprConstant<float> > T_expr;
351
352
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
353
d2,
354
_bz_VecExprConstant<float>(d3)));
355
}
356
357
// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, double)
358
template<class P_numtype1, class P_expr2>
359
inline
360
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
361
_bz_VecExpr<P_expr2>,
362
_bz_VecExprConstant<double> > >
363
where(const Vector<P_numtype1>& d1,
364
_bz_VecExpr<P_expr2> d2,
365
double d3)
366
{
367
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
368
_bz_VecExpr<P_expr2>,
369
_bz_VecExprConstant<double> > T_expr;
370
371
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
372
d2,
373
_bz_VecExprConstant<double>(d3)));
374
}
375
376
// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, long double)
377
template<class P_numtype1, class P_expr2>
378
inline
379
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
380
_bz_VecExpr<P_expr2>,
381
_bz_VecExprConstant<long double> > >
382
where(const Vector<P_numtype1>& d1,
383
_bz_VecExpr<P_expr2> d2,
384
long double d3)
385
{
386
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
387
_bz_VecExpr<P_expr2>,
388
_bz_VecExprConstant<long double> > T_expr;
389
390
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
391
d2,
392
_bz_VecExprConstant<long double>(d3)));
393
}
394
395
// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, complex<T3>)
396
#ifdef BZ_HAVE_COMPLEX
397
template<class P_numtype1, class P_expr2, class T3>
398
inline
399
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
400
_bz_VecExpr<P_expr2>,
401
_bz_VecExprConstant<complex<T3> > > >
402
where(const Vector<P_numtype1>& d1,
403
_bz_VecExpr<P_expr2> d2,
404
complex<T3> d3)
405
{
406
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
407
_bz_VecExpr<P_expr2>,
408
_bz_VecExprConstant<complex<T3> > > T_expr;
409
410
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
411
d2,
412
_bz_VecExprConstant<complex<T3> > (d3)));
413
}
414
#endif // BZ_HAVE_COMPLEX
415
416
// where(Vector<P_numtype1>, VectorPick<P_numtype2>, Vector<P_numtype3>)
417
template<class P_numtype1, class P_numtype2, class P_numtype3>
418
inline
419
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
420
VectorPickIterConst<P_numtype2>,
421
VectorIterConst<P_numtype3> > >
422
where(const Vector<P_numtype1>& d1,
423
const VectorPick<P_numtype2>& d2,
424
const Vector<P_numtype3>& d3)
425
{
426
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
427
VectorPickIterConst<P_numtype2>,
428
VectorIterConst<P_numtype3> > T_expr;
429
430
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
431
d2.beginFast(),
432
d3.beginFast()));
433
}
434
435
// where(Vector<P_numtype1>, VectorPick<P_numtype2>, _bz_VecExpr<P_expr3>)
436
template<class P_numtype1, class P_numtype2, class P_expr3>
437
inline
438
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
439
VectorPickIterConst<P_numtype2>,
440
_bz_VecExpr<P_expr3> > >
441
where(const Vector<P_numtype1>& d1,
442
const VectorPick<P_numtype2>& d2,
443
_bz_VecExpr<P_expr3> d3)
444
{
445
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
446
VectorPickIterConst<P_numtype2>,
447
_bz_VecExpr<P_expr3> > T_expr;
448
449
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
450
d2.beginFast(),
451
d3));
452
}
453
454
// where(Vector<P_numtype1>, VectorPick<P_numtype2>, VectorPick<P_numtype3>)
455
template<class P_numtype1, class P_numtype2, class P_numtype3>
456
inline
457
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
458
VectorPickIterConst<P_numtype2>,
459
VectorPickIterConst<P_numtype3> > >
460
where(const Vector<P_numtype1>& d1,
461
const VectorPick<P_numtype2>& d2,
462
const VectorPick<P_numtype3>& d3)
463
{
464
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
465
VectorPickIterConst<P_numtype2>,
466
VectorPickIterConst<P_numtype3> > T_expr;
467
468
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
469
d2.beginFast(),
470
d3.beginFast()));
471
}
472
473
// where(Vector<P_numtype1>, VectorPick<P_numtype2>, Range)
474
template<class P_numtype1, class P_numtype2>
475
inline
476
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
477
VectorPickIterConst<P_numtype2>,
478
Range > >
479
where(const Vector<P_numtype1>& d1,
480
const VectorPick<P_numtype2>& d2,
481
Range d3)
482
{
483
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
484
VectorPickIterConst<P_numtype2>,
485
Range > T_expr;
486
487
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
488
d2.beginFast(),
489
d3));
490
}
491
492
// where(Vector<P_numtype1>, VectorPick<P_numtype2>, TinyVector<P_numtype3, N_length3>)
493
template<class P_numtype1, class P_numtype2, class P_numtype3, int N_length3>
494
inline
495
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
496
VectorPickIterConst<P_numtype2>,
497
TinyVectorIterConst<P_numtype3, N_length3> > >
498
where(const Vector<P_numtype1>& d1,
499
const VectorPick<P_numtype2>& d2,
500
const TinyVector<P_numtype3, N_length3>& d3)
501
{
502
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
503
VectorPickIterConst<P_numtype2>,
504
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
505
506
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
507
d2.beginFast(),
508
d3.beginFast()));
509
}
510
511
// where(Vector<P_numtype1>, VectorPick<P_numtype2>, int)
512
template<class P_numtype1, class P_numtype2>
513
inline
514
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
515
VectorPickIterConst<P_numtype2>,
516
_bz_VecExprConstant<int> > >
517
where(const Vector<P_numtype1>& d1,
518
const VectorPick<P_numtype2>& d2,
519
int d3)
520
{
521
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
522
VectorPickIterConst<P_numtype2>,
523
_bz_VecExprConstant<int> > T_expr;
524
525
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
526
d2.beginFast(),
527
_bz_VecExprConstant<int>(d3)));
528
}
529
530
// where(Vector<P_numtype1>, VectorPick<P_numtype2>, float)
531
template<class P_numtype1, class P_numtype2>
532
inline
533
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
534
VectorPickIterConst<P_numtype2>,
535
_bz_VecExprConstant<float> > >
536
where(const Vector<P_numtype1>& d1,
537
const VectorPick<P_numtype2>& d2,
538
float d3)
539
{
540
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
541
VectorPickIterConst<P_numtype2>,
542
_bz_VecExprConstant<float> > T_expr;
543
544
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
545
d2.beginFast(),
546
_bz_VecExprConstant<float>(d3)));
547
}
548
549
// where(Vector<P_numtype1>, VectorPick<P_numtype2>, double)
550
template<class P_numtype1, class P_numtype2>
551
inline
552
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
553
VectorPickIterConst<P_numtype2>,
554
_bz_VecExprConstant<double> > >
555
where(const Vector<P_numtype1>& d1,
556
const VectorPick<P_numtype2>& d2,
557
double d3)
558
{
559
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
560
VectorPickIterConst<P_numtype2>,
561
_bz_VecExprConstant<double> > T_expr;
562
563
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
564
d2.beginFast(),
565
_bz_VecExprConstant<double>(d3)));
566
}
567
568
// where(Vector<P_numtype1>, VectorPick<P_numtype2>, long double)
569
template<class P_numtype1, class P_numtype2>
570
inline
571
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
572
VectorPickIterConst<P_numtype2>,
573
_bz_VecExprConstant<long double> > >
574
where(const Vector<P_numtype1>& d1,
575
const VectorPick<P_numtype2>& d2,
576
long double d3)
577
{
578
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
579
VectorPickIterConst<P_numtype2>,
580
_bz_VecExprConstant<long double> > T_expr;
581
582
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
583
d2.beginFast(),
584
_bz_VecExprConstant<long double>(d3)));
585
}
586
587
// where(Vector<P_numtype1>, VectorPick<P_numtype2>, complex<T3>)
588
#ifdef BZ_HAVE_COMPLEX
589
template<class P_numtype1, class P_numtype2, class T3>
590
inline
591
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
592
VectorPickIterConst<P_numtype2>,
593
_bz_VecExprConstant<complex<T3> > > >
594
where(const Vector<P_numtype1>& d1,
595
const VectorPick<P_numtype2>& d2,
596
complex<T3> d3)
597
{
598
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
599
VectorPickIterConst<P_numtype2>,
600
_bz_VecExprConstant<complex<T3> > > T_expr;
601
602
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
603
d2.beginFast(),
604
_bz_VecExprConstant<complex<T3> > (d3)));
605
}
606
#endif // BZ_HAVE_COMPLEX
607
608
// where(Vector<P_numtype1>, Range, Vector<P_numtype3>)
609
template<class P_numtype1, class P_numtype3>
610
inline
611
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
612
Range,
613
VectorIterConst<P_numtype3> > >
614
where(const Vector<P_numtype1>& d1,
615
Range d2,
616
const Vector<P_numtype3>& d3)
617
{
618
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
619
Range,
620
VectorIterConst<P_numtype3> > T_expr;
621
622
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
623
d2,
624
d3.beginFast()));
625
}
626
627
// where(Vector<P_numtype1>, Range, _bz_VecExpr<P_expr3>)
628
template<class P_numtype1, class P_expr3>
629
inline
630
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
631
Range,
632
_bz_VecExpr<P_expr3> > >
633
where(const Vector<P_numtype1>& d1,
634
Range d2,
635
_bz_VecExpr<P_expr3> d3)
636
{
637
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
638
Range,
639
_bz_VecExpr<P_expr3> > T_expr;
640
641
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
642
d2,
643
d3));
644
}
645
646
// where(Vector<P_numtype1>, Range, VectorPick<P_numtype3>)
647
template<class P_numtype1, class P_numtype3>
648
inline
649
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
650
Range,
651
VectorPickIterConst<P_numtype3> > >
652
where(const Vector<P_numtype1>& d1,
653
Range d2,
654
const VectorPick<P_numtype3>& d3)
655
{
656
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
657
Range,
658
VectorPickIterConst<P_numtype3> > T_expr;
659
660
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
661
d2,
662
d3.beginFast()));
663
}
664
665
// where(Vector<P_numtype1>, Range, Range)
666
template<class P_numtype1>
667
inline
668
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
669
Range,
670
Range > >
671
where(const Vector<P_numtype1>& d1,
672
Range d2,
673
Range d3)
674
{
675
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
676
Range,
677
Range > T_expr;
678
679
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
680
d2,
681
d3));
682
}
683
684
// where(Vector<P_numtype1>, Range, TinyVector<P_numtype3, N_length3>)
685
template<class P_numtype1, class P_numtype3, int N_length3>
686
inline
687
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
688
Range,
689
TinyVectorIterConst<P_numtype3, N_length3> > >
690
where(const Vector<P_numtype1>& d1,
691
Range d2,
692
const TinyVector<P_numtype3, N_length3>& d3)
693
{
694
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
695
Range,
696
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
697
698
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
699
d2,
700
d3.beginFast()));
701
}
702
703
// where(Vector<P_numtype1>, Range, int)
704
template<class P_numtype1>
705
inline
706
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
707
Range,
708
_bz_VecExprConstant<int> > >
709
where(const Vector<P_numtype1>& d1,
710
Range d2,
711
int d3)
712
{
713
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
714
Range,
715
_bz_VecExprConstant<int> > T_expr;
716
717
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
718
d2,
719
_bz_VecExprConstant<int>(d3)));
720
}
721
722
// where(Vector<P_numtype1>, Range, float)
723
template<class P_numtype1>
724
inline
725
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
726
Range,
727
_bz_VecExprConstant<float> > >
728
where(const Vector<P_numtype1>& d1,
729
Range d2,
730
float d3)
731
{
732
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
733
Range,
734
_bz_VecExprConstant<float> > T_expr;
735
736
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
737
d2,
738
_bz_VecExprConstant<float>(d3)));
739
}
740
741
// where(Vector<P_numtype1>, Range, double)
742
template<class P_numtype1>
743
inline
744
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
745
Range,
746
_bz_VecExprConstant<double> > >
747
where(const Vector<P_numtype1>& d1,
748
Range d2,
749
double d3)
750
{
751
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
752
Range,
753
_bz_VecExprConstant<double> > T_expr;
754
755
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
756
d2,
757
_bz_VecExprConstant<double>(d3)));
758
}
759
760
// where(Vector<P_numtype1>, Range, long double)
761
template<class P_numtype1>
762
inline
763
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
764
Range,
765
_bz_VecExprConstant<long double> > >
766
where(const Vector<P_numtype1>& d1,
767
Range d2,
768
long double d3)
769
{
770
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
771
Range,
772
_bz_VecExprConstant<long double> > T_expr;
773
774
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
775
d2,
776
_bz_VecExprConstant<long double>(d3)));
777
}
778
779
// where(Vector<P_numtype1>, Range, complex<T3>)
780
#ifdef BZ_HAVE_COMPLEX
781
template<class P_numtype1, class T3>
782
inline
783
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
784
Range,
785
_bz_VecExprConstant<complex<T3> > > >
786
where(const Vector<P_numtype1>& d1,
787
Range d2,
788
complex<T3> d3)
789
{
790
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
791
Range,
792
_bz_VecExprConstant<complex<T3> > > T_expr;
793
794
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
795
d2,
796
_bz_VecExprConstant<complex<T3> > (d3)));
797
}
798
#endif // BZ_HAVE_COMPLEX
799
800
// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, Vector<P_numtype3>)
801
template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3>
802
inline
803
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
804
TinyVectorIterConst<P_numtype2, N_length2>,
805
VectorIterConst<P_numtype3> > >
806
where(const Vector<P_numtype1>& d1,
807
const TinyVector<P_numtype2, N_length2>& d2,
808
const Vector<P_numtype3>& d3)
809
{
810
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
811
TinyVectorIterConst<P_numtype2, N_length2>,
812
VectorIterConst<P_numtype3> > T_expr;
813
814
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
815
d2.beginFast(),
816
d3.beginFast()));
817
}
818
819
// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, _bz_VecExpr<P_expr3>)
820
template<class P_numtype1, class P_numtype2, int N_length2, class P_expr3>
821
inline
822
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
823
TinyVectorIterConst<P_numtype2, N_length2>,
824
_bz_VecExpr<P_expr3> > >
825
where(const Vector<P_numtype1>& d1,
826
const TinyVector<P_numtype2, N_length2>& d2,
827
_bz_VecExpr<P_expr3> d3)
828
{
829
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
830
TinyVectorIterConst<P_numtype2, N_length2>,
831
_bz_VecExpr<P_expr3> > T_expr;
832
833
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
834
d2.beginFast(),
835
d3));
836
}
837
838
// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, VectorPick<P_numtype3>)
839
template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3>
840
inline
841
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
842
TinyVectorIterConst<P_numtype2, N_length2>,
843
VectorPickIterConst<P_numtype3> > >
844
where(const Vector<P_numtype1>& d1,
845
const TinyVector<P_numtype2, N_length2>& d2,
846
const VectorPick<P_numtype3>& d3)
847
{
848
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
849
TinyVectorIterConst<P_numtype2, N_length2>,
850
VectorPickIterConst<P_numtype3> > T_expr;
851
852
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
853
d2.beginFast(),
854
d3.beginFast()));
855
}
856
857
// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, Range)
858
template<class P_numtype1, class P_numtype2, int N_length2>
859
inline
860
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
861
TinyVectorIterConst<P_numtype2, N_length2>,
862
Range > >
863
where(const Vector<P_numtype1>& d1,
864
const TinyVector<P_numtype2, N_length2>& d2,
865
Range d3)
866
{
867
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
868
TinyVectorIterConst<P_numtype2, N_length2>,
869
Range > T_expr;
870
871
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
872
d2.beginFast(),
873
d3));
874
}
875
876
// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, TinyVector<P_numtype3, N_length3>)
877
template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3, int N_length3>
878
inline
879
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
880
TinyVectorIterConst<P_numtype2, N_length2>,
881
TinyVectorIterConst<P_numtype3, N_length3> > >
882
where(const Vector<P_numtype1>& d1,
883
const TinyVector<P_numtype2, N_length2>& d2,
884
const TinyVector<P_numtype3, N_length3>& d3)
885
{
886
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
887
TinyVectorIterConst<P_numtype2, N_length2>,
888
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
889
890
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
891
d2.beginFast(),
892
d3.beginFast()));
893
}
894
895
// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, int)
896
template<class P_numtype1, class P_numtype2, int N_length2>
897
inline
898
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
899
TinyVectorIterConst<P_numtype2, N_length2>,
900
_bz_VecExprConstant<int> > >
901
where(const Vector<P_numtype1>& d1,
902
const TinyVector<P_numtype2, N_length2>& d2,
903
int d3)
904
{
905
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
906
TinyVectorIterConst<P_numtype2, N_length2>,
907
_bz_VecExprConstant<int> > T_expr;
908
909
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
910
d2.beginFast(),
911
_bz_VecExprConstant<int>(d3)));
912
}
913
914
// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, float)
915
template<class P_numtype1, class P_numtype2, int N_length2>
916
inline
917
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
918
TinyVectorIterConst<P_numtype2, N_length2>,
919
_bz_VecExprConstant<float> > >
920
where(const Vector<P_numtype1>& d1,
921
const TinyVector<P_numtype2, N_length2>& d2,
922
float d3)
923
{
924
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
925
TinyVectorIterConst<P_numtype2, N_length2>,
926
_bz_VecExprConstant<float> > T_expr;
927
928
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
929
d2.beginFast(),
930
_bz_VecExprConstant<float>(d3)));
931
}
932
933
// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, double)
934
template<class P_numtype1, class P_numtype2, int N_length2>
935
inline
936
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
937
TinyVectorIterConst<P_numtype2, N_length2>,
938
_bz_VecExprConstant<double> > >
939
where(const Vector<P_numtype1>& d1,
940
const TinyVector<P_numtype2, N_length2>& d2,
941
double d3)
942
{
943
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
944
TinyVectorIterConst<P_numtype2, N_length2>,
945
_bz_VecExprConstant<double> > T_expr;
946
947
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
948
d2.beginFast(),
949
_bz_VecExprConstant<double>(d3)));
950
}
951
952
// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, long double)
953
template<class P_numtype1, class P_numtype2, int N_length2>
954
inline
955
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
956
TinyVectorIterConst<P_numtype2, N_length2>,
957
_bz_VecExprConstant<long double> > >
958
where(const Vector<P_numtype1>& d1,
959
const TinyVector<P_numtype2, N_length2>& d2,
960
long double d3)
961
{
962
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
963
TinyVectorIterConst<P_numtype2, N_length2>,
964
_bz_VecExprConstant<long double> > T_expr;
965
966
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
967
d2.beginFast(),
968
_bz_VecExprConstant<long double>(d3)));
969
}
970
971
// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, complex<T3>)
972
#ifdef BZ_HAVE_COMPLEX
973
template<class P_numtype1, class P_numtype2, int N_length2, class T3>
974
inline
975
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
976
TinyVectorIterConst<P_numtype2, N_length2>,
977
_bz_VecExprConstant<complex<T3> > > >
978
where(const Vector<P_numtype1>& d1,
979
const TinyVector<P_numtype2, N_length2>& d2,
980
complex<T3> d3)
981
{
982
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
983
TinyVectorIterConst<P_numtype2, N_length2>,
984
_bz_VecExprConstant<complex<T3> > > T_expr;
985
986
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
987
d2.beginFast(),
988
_bz_VecExprConstant<complex<T3> > (d3)));
989
}
990
#endif // BZ_HAVE_COMPLEX
991
992
// where(Vector<P_numtype1>, int, Vector<P_numtype3>)
993
template<class P_numtype1, class P_numtype3>
994
inline
995
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
996
_bz_VecExprConstant<int>,
997
VectorIterConst<P_numtype3> > >
998
where(const Vector<P_numtype1>& d1,
999
int d2,
1000
const Vector<P_numtype3>& d3)
1001
{
1002
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1003
_bz_VecExprConstant<int>,
1004
VectorIterConst<P_numtype3> > T_expr;
1005
1006
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1007
_bz_VecExprConstant<int>(d2),
1008
d3.beginFast()));
1009
}
1010
1011
// where(Vector<P_numtype1>, int, _bz_VecExpr<P_expr3>)
1012
template<class P_numtype1, class P_expr3>
1013
inline
1014
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1015
_bz_VecExprConstant<int>,
1016
_bz_VecExpr<P_expr3> > >
1017
where(const Vector<P_numtype1>& d1,
1018
int d2,
1019
_bz_VecExpr<P_expr3> d3)
1020
{
1021
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1022
_bz_VecExprConstant<int>,
1023
_bz_VecExpr<P_expr3> > T_expr;
1024
1025
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1026
_bz_VecExprConstant<int>(d2),
1027
d3));
1028
}
1029
1030
// where(Vector<P_numtype1>, int, VectorPick<P_numtype3>)
1031
template<class P_numtype1, class P_numtype3>
1032
inline
1033
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1034
_bz_VecExprConstant<int>,
1035
VectorPickIterConst<P_numtype3> > >
1036
where(const Vector<P_numtype1>& d1,
1037
int d2,
1038
const VectorPick<P_numtype3>& d3)
1039
{
1040
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1041
_bz_VecExprConstant<int>,
1042
VectorPickIterConst<P_numtype3> > T_expr;
1043
1044
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1045
_bz_VecExprConstant<int>(d2),
1046
d3.beginFast()));
1047
}
1048
1049
// where(Vector<P_numtype1>, int, Range)
1050
template<class P_numtype1>
1051
inline
1052
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1053
_bz_VecExprConstant<int>,
1054
Range > >
1055
where(const Vector<P_numtype1>& d1,
1056
int d2,
1057
Range d3)
1058
{
1059
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1060
_bz_VecExprConstant<int>,
1061
Range > T_expr;
1062
1063
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1064
_bz_VecExprConstant<int>(d2),
1065
d3));
1066
}
1067
1068
// where(Vector<P_numtype1>, int, TinyVector<P_numtype3, N_length3>)
1069
template<class P_numtype1, class P_numtype3, int N_length3>
1070
inline
1071
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1072
_bz_VecExprConstant<int>,
1073
TinyVectorIterConst<P_numtype3, N_length3> > >
1074
where(const Vector<P_numtype1>& d1,
1075
int d2,
1076
const TinyVector<P_numtype3, N_length3>& d3)
1077
{
1078
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1079
_bz_VecExprConstant<int>,
1080
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
1081
1082
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1083
_bz_VecExprConstant<int>(d2),
1084
d3.beginFast()));
1085
}
1086
1087
// where(Vector<P_numtype1>, int, int)
1088
template<class P_numtype1>
1089
inline
1090
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1091
_bz_VecExprConstant<int>,
1092
_bz_VecExprConstant<int> > >
1093
where(const Vector<P_numtype1>& d1,
1094
int d2,
1095
int d3)
1096
{
1097
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1098
_bz_VecExprConstant<int>,
1099
_bz_VecExprConstant<int> > T_expr;
1100
1101
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1102
_bz_VecExprConstant<int>(d2),
1103
_bz_VecExprConstant<int>(d3)));
1104
}
1105
1106
// where(Vector<P_numtype1>, float, Vector<P_numtype3>)
1107
template<class P_numtype1, class P_numtype3>
1108
inline
1109
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1110
_bz_VecExprConstant<float>,
1111
VectorIterConst<P_numtype3> > >
1112
where(const Vector<P_numtype1>& d1,
1113
float d2,
1114
const Vector<P_numtype3>& d3)
1115
{
1116
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1117
_bz_VecExprConstant<float>,
1118
VectorIterConst<P_numtype3> > T_expr;
1119
1120
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1121
_bz_VecExprConstant<float>(d2),
1122
d3.beginFast()));
1123
}
1124
1125
// where(Vector<P_numtype1>, float, _bz_VecExpr<P_expr3>)
1126
template<class P_numtype1, class P_expr3>
1127
inline
1128
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1129
_bz_VecExprConstant<float>,
1130
_bz_VecExpr<P_expr3> > >
1131
where(const Vector<P_numtype1>& d1,
1132
float d2,
1133
_bz_VecExpr<P_expr3> d3)
1134
{
1135
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1136
_bz_VecExprConstant<float>,
1137
_bz_VecExpr<P_expr3> > T_expr;
1138
1139
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1140
_bz_VecExprConstant<float>(d2),
1141
d3));
1142
}
1143
1144
// where(Vector<P_numtype1>, float, VectorPick<P_numtype3>)
1145
template<class P_numtype1, class P_numtype3>
1146
inline
1147
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1148
_bz_VecExprConstant<float>,
1149
VectorPickIterConst<P_numtype3> > >
1150
where(const Vector<P_numtype1>& d1,
1151
float d2,
1152
const VectorPick<P_numtype3>& d3)
1153
{
1154
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1155
_bz_VecExprConstant<float>,
1156
VectorPickIterConst<P_numtype3> > T_expr;
1157
1158
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1159
_bz_VecExprConstant<float>(d2),
1160
d3.beginFast()));
1161
}
1162
1163
// where(Vector<P_numtype1>, float, Range)
1164
template<class P_numtype1>
1165
inline
1166
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1167
_bz_VecExprConstant<float>,
1168
Range > >
1169
where(const Vector<P_numtype1>& d1,
1170
float d2,
1171
Range d3)
1172
{
1173
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1174
_bz_VecExprConstant<float>,
1175
Range > T_expr;
1176
1177
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1178
_bz_VecExprConstant<float>(d2),
1179
d3));
1180
}
1181
1182
// where(Vector<P_numtype1>, float, TinyVector<P_numtype3, N_length3>)
1183
template<class P_numtype1, class P_numtype3, int N_length3>
1184
inline
1185
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1186
_bz_VecExprConstant<float>,
1187
TinyVectorIterConst<P_numtype3, N_length3> > >
1188
where(const Vector<P_numtype1>& d1,
1189
float d2,
1190
const TinyVector<P_numtype3, N_length3>& d3)
1191
{
1192
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1193
_bz_VecExprConstant<float>,
1194
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
1195
1196
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1197
_bz_VecExprConstant<float>(d2),
1198
d3.beginFast()));
1199
}
1200
1201
// where(Vector<P_numtype1>, float, float)
1202
template<class P_numtype1>
1203
inline
1204
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1205
_bz_VecExprConstant<float>,
1206
_bz_VecExprConstant<float> > >
1207
where(const Vector<P_numtype1>& d1,
1208
float d2,
1209
float d3)
1210
{
1211
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1212
_bz_VecExprConstant<float>,
1213
_bz_VecExprConstant<float> > T_expr;
1214
1215
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1216
_bz_VecExprConstant<float>(d2),
1217
_bz_VecExprConstant<float>(d3)));
1218
}
1219
1220
// where(Vector<P_numtype1>, double, Vector<P_numtype3>)
1221
template<class P_numtype1, class P_numtype3>
1222
inline
1223
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1224
_bz_VecExprConstant<double>,
1225
VectorIterConst<P_numtype3> > >
1226
where(const Vector<P_numtype1>& d1,
1227
double d2,
1228
const Vector<P_numtype3>& d3)
1229
{
1230
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1231
_bz_VecExprConstant<double>,
1232
VectorIterConst<P_numtype3> > T_expr;
1233
1234
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1235
_bz_VecExprConstant<double>(d2),
1236
d3.beginFast()));
1237
}
1238
1239
// where(Vector<P_numtype1>, double, _bz_VecExpr<P_expr3>)
1240
template<class P_numtype1, class P_expr3>
1241
inline
1242
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1243
_bz_VecExprConstant<double>,
1244
_bz_VecExpr<P_expr3> > >
1245
where(const Vector<P_numtype1>& d1,
1246
double d2,
1247
_bz_VecExpr<P_expr3> d3)
1248
{
1249
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1250
_bz_VecExprConstant<double>,
1251
_bz_VecExpr<P_expr3> > T_expr;
1252
1253
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1254
_bz_VecExprConstant<double>(d2),
1255
d3));
1256
}
1257
1258
// where(Vector<P_numtype1>, double, VectorPick<P_numtype3>)
1259
template<class P_numtype1, class P_numtype3>
1260
inline
1261
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1262
_bz_VecExprConstant<double>,
1263
VectorPickIterConst<P_numtype3> > >
1264
where(const Vector<P_numtype1>& d1,
1265
double d2,
1266
const VectorPick<P_numtype3>& d3)
1267
{
1268
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1269
_bz_VecExprConstant<double>,
1270
VectorPickIterConst<P_numtype3> > T_expr;
1271
1272
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1273
_bz_VecExprConstant<double>(d2),
1274
d3.beginFast()));
1275
}
1276
1277
// where(Vector<P_numtype1>, double, Range)
1278
template<class P_numtype1>
1279
inline
1280
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1281
_bz_VecExprConstant<double>,
1282
Range > >
1283
where(const Vector<P_numtype1>& d1,
1284
double d2,
1285
Range d3)
1286
{
1287
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1288
_bz_VecExprConstant<double>,
1289
Range > T_expr;
1290
1291
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1292
_bz_VecExprConstant<double>(d2),
1293
d3));
1294
}
1295
1296
// where(Vector<P_numtype1>, double, TinyVector<P_numtype3, N_length3>)
1297
template<class P_numtype1, class P_numtype3, int N_length3>
1298
inline
1299
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1300
_bz_VecExprConstant<double>,
1301
TinyVectorIterConst<P_numtype3, N_length3> > >
1302
where(const Vector<P_numtype1>& d1,
1303
double d2,
1304
const TinyVector<P_numtype3, N_length3>& d3)
1305
{
1306
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1307
_bz_VecExprConstant<double>,
1308
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
1309
1310
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1311
_bz_VecExprConstant<double>(d2),
1312
d3.beginFast()));
1313
}
1314
1315
// where(Vector<P_numtype1>, double, double)
1316
template<class P_numtype1>
1317
inline
1318
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1319
_bz_VecExprConstant<double>,
1320
_bz_VecExprConstant<double> > >
1321
where(const Vector<P_numtype1>& d1,
1322
double d2,
1323
double d3)
1324
{
1325
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1326
_bz_VecExprConstant<double>,
1327
_bz_VecExprConstant<double> > T_expr;
1328
1329
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1330
_bz_VecExprConstant<double>(d2),
1331
_bz_VecExprConstant<double>(d3)));
1332
}
1333
1334
// where(Vector<P_numtype1>, long double, Vector<P_numtype3>)
1335
template<class P_numtype1, class P_numtype3>
1336
inline
1337
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1338
_bz_VecExprConstant<long double>,
1339
VectorIterConst<P_numtype3> > >
1340
where(const Vector<P_numtype1>& d1,
1341
long double d2,
1342
const Vector<P_numtype3>& d3)
1343
{
1344
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1345
_bz_VecExprConstant<long double>,
1346
VectorIterConst<P_numtype3> > T_expr;
1347
1348
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1349
_bz_VecExprConstant<long double>(d2),
1350
d3.beginFast()));
1351
}
1352
1353
// where(Vector<P_numtype1>, long double, _bz_VecExpr<P_expr3>)
1354
template<class P_numtype1, class P_expr3>
1355
inline
1356
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1357
_bz_VecExprConstant<long double>,
1358
_bz_VecExpr<P_expr3> > >
1359
where(const Vector<P_numtype1>& d1,
1360
long double d2,
1361
_bz_VecExpr<P_expr3> d3)
1362
{
1363
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1364
_bz_VecExprConstant<long double>,
1365
_bz_VecExpr<P_expr3> > T_expr;
1366
1367
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1368
_bz_VecExprConstant<long double>(d2),
1369
d3));
1370
}
1371
1372
// where(Vector<P_numtype1>, long double, VectorPick<P_numtype3>)
1373
template<class P_numtype1, class P_numtype3>
1374
inline
1375
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1376
_bz_VecExprConstant<long double>,
1377
VectorPickIterConst<P_numtype3> > >
1378
where(const Vector<P_numtype1>& d1,
1379
long double d2,
1380
const VectorPick<P_numtype3>& d3)
1381
{
1382
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1383
_bz_VecExprConstant<long double>,
1384
VectorPickIterConst<P_numtype3> > T_expr;
1385
1386
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1387
_bz_VecExprConstant<long double>(d2),
1388
d3.beginFast()));
1389
}
1390
1391
// where(Vector<P_numtype1>, long double, Range)
1392
template<class P_numtype1>
1393
inline
1394
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1395
_bz_VecExprConstant<long double>,
1396
Range > >
1397
where(const Vector<P_numtype1>& d1,
1398
long double d2,
1399
Range d3)
1400
{
1401
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1402
_bz_VecExprConstant<long double>,
1403
Range > T_expr;
1404
1405
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1406
_bz_VecExprConstant<long double>(d2),
1407
d3));
1408
}
1409
1410
// where(Vector<P_numtype1>, long double, TinyVector<P_numtype3, N_length3>)
1411
template<class P_numtype1, class P_numtype3, int N_length3>
1412
inline
1413
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1414
_bz_VecExprConstant<long double>,
1415
TinyVectorIterConst<P_numtype3, N_length3> > >
1416
where(const Vector<P_numtype1>& d1,
1417
long double d2,
1418
const TinyVector<P_numtype3, N_length3>& d3)
1419
{
1420
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1421
_bz_VecExprConstant<long double>,
1422
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
1423
1424
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1425
_bz_VecExprConstant<long double>(d2),
1426
d3.beginFast()));
1427
}
1428
1429
// where(Vector<P_numtype1>, long double, long double)
1430
template<class P_numtype1>
1431
inline
1432
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1433
_bz_VecExprConstant<long double>,
1434
_bz_VecExprConstant<long double> > >
1435
where(const Vector<P_numtype1>& d1,
1436
long double d2,
1437
long double d3)
1438
{
1439
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1440
_bz_VecExprConstant<long double>,
1441
_bz_VecExprConstant<long double> > T_expr;
1442
1443
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1444
_bz_VecExprConstant<long double>(d2),
1445
_bz_VecExprConstant<long double>(d3)));
1446
}
1447
1448
// where(Vector<P_numtype1>, complex<T2>, Vector<P_numtype3>)
1449
#ifdef BZ_HAVE_COMPLEX
1450
template<class P_numtype1, class T2, class P_numtype3>
1451
inline
1452
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1453
_bz_VecExprConstant<complex<T2> > ,
1454
VectorIterConst<P_numtype3> > >
1455
where(const Vector<P_numtype1>& d1,
1456
complex<T2> d2,
1457
const Vector<P_numtype3>& d3)
1458
{
1459
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1460
_bz_VecExprConstant<complex<T2> > ,
1461
VectorIterConst<P_numtype3> > T_expr;
1462
1463
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1464
_bz_VecExprConstant<complex<T2> > (d2),
1465
d3.beginFast()));
1466
}
1467
#endif // BZ_HAVE_COMPLEX
1468
1469
// where(Vector<P_numtype1>, complex<T2>, _bz_VecExpr<P_expr3>)
1470
#ifdef BZ_HAVE_COMPLEX
1471
template<class P_numtype1, class T2, class P_expr3>
1472
inline
1473
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1474
_bz_VecExprConstant<complex<T2> > ,
1475
_bz_VecExpr<P_expr3> > >
1476
where(const Vector<P_numtype1>& d1,
1477
complex<T2> d2,
1478
_bz_VecExpr<P_expr3> d3)
1479
{
1480
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1481
_bz_VecExprConstant<complex<T2> > ,
1482
_bz_VecExpr<P_expr3> > T_expr;
1483
1484
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1485
_bz_VecExprConstant<complex<T2> > (d2),
1486
d3));
1487
}
1488
#endif // BZ_HAVE_COMPLEX
1489
1490
// where(Vector<P_numtype1>, complex<T2>, VectorPick<P_numtype3>)
1491
#ifdef BZ_HAVE_COMPLEX
1492
template<class P_numtype1, class T2, class P_numtype3>
1493
inline
1494
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1495
_bz_VecExprConstant<complex<T2> > ,
1496
VectorPickIterConst<P_numtype3> > >
1497
where(const Vector<P_numtype1>& d1,
1498
complex<T2> d2,
1499
const VectorPick<P_numtype3>& d3)
1500
{
1501
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1502
_bz_VecExprConstant<complex<T2> > ,
1503
VectorPickIterConst<P_numtype3> > T_expr;
1504
1505
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1506
_bz_VecExprConstant<complex<T2> > (d2),
1507
d3.beginFast()));
1508
}
1509
#endif // BZ_HAVE_COMPLEX
1510
1511
// where(Vector<P_numtype1>, complex<T2>, Range)
1512
#ifdef BZ_HAVE_COMPLEX
1513
template<class P_numtype1, class T2>
1514
inline
1515
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1516
_bz_VecExprConstant<complex<T2> > ,
1517
Range > >
1518
where(const Vector<P_numtype1>& d1,
1519
complex<T2> d2,
1520
Range d3)
1521
{
1522
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1523
_bz_VecExprConstant<complex<T2> > ,
1524
Range > T_expr;
1525
1526
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1527
_bz_VecExprConstant<complex<T2> > (d2),
1528
d3));
1529
}
1530
#endif // BZ_HAVE_COMPLEX
1531
1532
// where(Vector<P_numtype1>, complex<T2>, TinyVector<P_numtype3, N_length3>)
1533
#ifdef BZ_HAVE_COMPLEX
1534
template<class P_numtype1, class T2, class P_numtype3, int N_length3>
1535
inline
1536
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1537
_bz_VecExprConstant<complex<T2> > ,
1538
TinyVectorIterConst<P_numtype3, N_length3> > >
1539
where(const Vector<P_numtype1>& d1,
1540
complex<T2> d2,
1541
const TinyVector<P_numtype3, N_length3>& d3)
1542
{
1543
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1544
_bz_VecExprConstant<complex<T2> > ,
1545
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
1546
1547
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1548
_bz_VecExprConstant<complex<T2> > (d2),
1549
d3.beginFast()));
1550
}
1551
#endif // BZ_HAVE_COMPLEX
1552
1553
// where(Vector<P_numtype1>, complex<T2>, complex<T3>)
1554
#ifdef BZ_HAVE_COMPLEX
1555
template<class P_numtype1, class T2, class T3>
1556
inline
1557
_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>,
1558
_bz_VecExprConstant<complex<T2> > ,
1559
_bz_VecExprConstant<complex<T3> > > >
1560
where(const Vector<P_numtype1>& d1,
1561
complex<T2> d2,
1562
complex<T3> d3)
1563
{
1564
typedef _bz_VecWhere<VectorIterConst<P_numtype1>,
1565
_bz_VecExprConstant<complex<T2> > ,
1566
_bz_VecExprConstant<complex<T3> > > T_expr;
1567
1568
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
1569
_bz_VecExprConstant<complex<T2> > (d2),
1570
_bz_VecExprConstant<complex<T3> > (d3)));
1571
}
1572
#endif // BZ_HAVE_COMPLEX
1573
1574
// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, Vector<P_numtype3>)
1575
template<class P_expr1, class P_numtype2, class P_numtype3>
1576
inline
1577
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1578
VectorIterConst<P_numtype2>,
1579
VectorIterConst<P_numtype3> > >
1580
where(_bz_VecExpr<P_expr1> d1,
1581
const Vector<P_numtype2>& d2,
1582
const Vector<P_numtype3>& d3)
1583
{
1584
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1585
VectorIterConst<P_numtype2>,
1586
VectorIterConst<P_numtype3> > T_expr;
1587
1588
return _bz_VecExpr<T_expr>(T_expr(d1,
1589
d2.beginFast(),
1590
d3.beginFast()));
1591
}
1592
1593
// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, _bz_VecExpr<P_expr3>)
1594
template<class P_expr1, class P_numtype2, class P_expr3>
1595
inline
1596
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1597
VectorIterConst<P_numtype2>,
1598
_bz_VecExpr<P_expr3> > >
1599
where(_bz_VecExpr<P_expr1> d1,
1600
const Vector<P_numtype2>& d2,
1601
_bz_VecExpr<P_expr3> d3)
1602
{
1603
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1604
VectorIterConst<P_numtype2>,
1605
_bz_VecExpr<P_expr3> > T_expr;
1606
1607
return _bz_VecExpr<T_expr>(T_expr(d1,
1608
d2.beginFast(),
1609
d3));
1610
}
1611
1612
// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, VectorPick<P_numtype3>)
1613
template<class P_expr1, class P_numtype2, class P_numtype3>
1614
inline
1615
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1616
VectorIterConst<P_numtype2>,
1617
VectorPickIterConst<P_numtype3> > >
1618
where(_bz_VecExpr<P_expr1> d1,
1619
const Vector<P_numtype2>& d2,
1620
const VectorPick<P_numtype3>& d3)
1621
{
1622
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1623
VectorIterConst<P_numtype2>,
1624
VectorPickIterConst<P_numtype3> > T_expr;
1625
1626
return _bz_VecExpr<T_expr>(T_expr(d1,
1627
d2.beginFast(),
1628
d3.beginFast()));
1629
}
1630
1631
// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, Range)
1632
template<class P_expr1, class P_numtype2>
1633
inline
1634
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1635
VectorIterConst<P_numtype2>,
1636
Range > >
1637
where(_bz_VecExpr<P_expr1> d1,
1638
const Vector<P_numtype2>& d2,
1639
Range d3)
1640
{
1641
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1642
VectorIterConst<P_numtype2>,
1643
Range > T_expr;
1644
1645
return _bz_VecExpr<T_expr>(T_expr(d1,
1646
d2.beginFast(),
1647
d3));
1648
}
1649
1650
// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, TinyVector<P_numtype3, N_length3>)
1651
template<class P_expr1, class P_numtype2, class P_numtype3, int N_length3>
1652
inline
1653
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1654
VectorIterConst<P_numtype2>,
1655
TinyVectorIterConst<P_numtype3, N_length3> > >
1656
where(_bz_VecExpr<P_expr1> d1,
1657
const Vector<P_numtype2>& d2,
1658
const TinyVector<P_numtype3, N_length3>& d3)
1659
{
1660
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1661
VectorIterConst<P_numtype2>,
1662
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
1663
1664
return _bz_VecExpr<T_expr>(T_expr(d1,
1665
d2.beginFast(),
1666
d3.beginFast()));
1667
}
1668
1669
// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, int)
1670
template<class P_expr1, class P_numtype2>
1671
inline
1672
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1673
VectorIterConst<P_numtype2>,
1674
_bz_VecExprConstant<int> > >
1675
where(_bz_VecExpr<P_expr1> d1,
1676
const Vector<P_numtype2>& d2,
1677
int d3)
1678
{
1679
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1680
VectorIterConst<P_numtype2>,
1681
_bz_VecExprConstant<int> > T_expr;
1682
1683
return _bz_VecExpr<T_expr>(T_expr(d1,
1684
d2.beginFast(),
1685
_bz_VecExprConstant<int>(d3)));
1686
}
1687
1688
// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, float)
1689
template<class P_expr1, class P_numtype2>
1690
inline
1691
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1692
VectorIterConst<P_numtype2>,
1693
_bz_VecExprConstant<float> > >
1694
where(_bz_VecExpr<P_expr1> d1,
1695
const Vector<P_numtype2>& d2,
1696
float d3)
1697
{
1698
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1699
VectorIterConst<P_numtype2>,
1700
_bz_VecExprConstant<float> > T_expr;
1701
1702
return _bz_VecExpr<T_expr>(T_expr(d1,
1703
d2.beginFast(),
1704
_bz_VecExprConstant<float>(d3)));
1705
}
1706
1707
// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, double)
1708
template<class P_expr1, class P_numtype2>
1709
inline
1710
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1711
VectorIterConst<P_numtype2>,
1712
_bz_VecExprConstant<double> > >
1713
where(_bz_VecExpr<P_expr1> d1,
1714
const Vector<P_numtype2>& d2,
1715
double d3)
1716
{
1717
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1718
VectorIterConst<P_numtype2>,
1719
_bz_VecExprConstant<double> > T_expr;
1720
1721
return _bz_VecExpr<T_expr>(T_expr(d1,
1722
d2.beginFast(),
1723
_bz_VecExprConstant<double>(d3)));
1724
}
1725
1726
// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, long double)
1727
template<class P_expr1, class P_numtype2>
1728
inline
1729
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1730
VectorIterConst<P_numtype2>,
1731
_bz_VecExprConstant<long double> > >
1732
where(_bz_VecExpr<P_expr1> d1,
1733
const Vector<P_numtype2>& d2,
1734
long double d3)
1735
{
1736
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1737
VectorIterConst<P_numtype2>,
1738
_bz_VecExprConstant<long double> > T_expr;
1739
1740
return _bz_VecExpr<T_expr>(T_expr(d1,
1741
d2.beginFast(),
1742
_bz_VecExprConstant<long double>(d3)));
1743
}
1744
1745
// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, complex<T3>)
1746
#ifdef BZ_HAVE_COMPLEX
1747
template<class P_expr1, class P_numtype2, class T3>
1748
inline
1749
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1750
VectorIterConst<P_numtype2>,
1751
_bz_VecExprConstant<complex<T3> > > >
1752
where(_bz_VecExpr<P_expr1> d1,
1753
const Vector<P_numtype2>& d2,
1754
complex<T3> d3)
1755
{
1756
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1757
VectorIterConst<P_numtype2>,
1758
_bz_VecExprConstant<complex<T3> > > T_expr;
1759
1760
return _bz_VecExpr<T_expr>(T_expr(d1,
1761
d2.beginFast(),
1762
_bz_VecExprConstant<complex<T3> > (d3)));
1763
}
1764
#endif // BZ_HAVE_COMPLEX
1765
1766
// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, Vector<P_numtype3>)
1767
template<class P_expr1, class P_expr2, class P_numtype3>
1768
inline
1769
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1770
_bz_VecExpr<P_expr2>,
1771
VectorIterConst<P_numtype3> > >
1772
where(_bz_VecExpr<P_expr1> d1,
1773
_bz_VecExpr<P_expr2> d2,
1774
const Vector<P_numtype3>& d3)
1775
{
1776
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1777
_bz_VecExpr<P_expr2>,
1778
VectorIterConst<P_numtype3> > T_expr;
1779
1780
return _bz_VecExpr<T_expr>(T_expr(d1,
1781
d2,
1782
d3.beginFast()));
1783
}
1784
1785
// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, _bz_VecExpr<P_expr3>)
1786
template<class P_expr1, class P_expr2, class P_expr3>
1787
inline
1788
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1789
_bz_VecExpr<P_expr2>,
1790
_bz_VecExpr<P_expr3> > >
1791
where(_bz_VecExpr<P_expr1> d1,
1792
_bz_VecExpr<P_expr2> d2,
1793
_bz_VecExpr<P_expr3> d3)
1794
{
1795
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1796
_bz_VecExpr<P_expr2>,
1797
_bz_VecExpr<P_expr3> > T_expr;
1798
1799
return _bz_VecExpr<T_expr>(T_expr(d1,
1800
d2,
1801
d3));
1802
}
1803
1804
// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, VectorPick<P_numtype3>)
1805
template<class P_expr1, class P_expr2, class P_numtype3>
1806
inline
1807
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1808
_bz_VecExpr<P_expr2>,
1809
VectorPickIterConst<P_numtype3> > >
1810
where(_bz_VecExpr<P_expr1> d1,
1811
_bz_VecExpr<P_expr2> d2,
1812
const VectorPick<P_numtype3>& d3)
1813
{
1814
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1815
_bz_VecExpr<P_expr2>,
1816
VectorPickIterConst<P_numtype3> > T_expr;
1817
1818
return _bz_VecExpr<T_expr>(T_expr(d1,
1819
d2,
1820
d3.beginFast()));
1821
}
1822
1823
// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, Range)
1824
template<class P_expr1, class P_expr2>
1825
inline
1826
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1827
_bz_VecExpr<P_expr2>,
1828
Range > >
1829
where(_bz_VecExpr<P_expr1> d1,
1830
_bz_VecExpr<P_expr2> d2,
1831
Range d3)
1832
{
1833
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1834
_bz_VecExpr<P_expr2>,
1835
Range > T_expr;
1836
1837
return _bz_VecExpr<T_expr>(T_expr(d1,
1838
d2,
1839
d3));
1840
}
1841
1842
// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, TinyVector<P_numtype3, N_length3>)
1843
template<class P_expr1, class P_expr2, class P_numtype3, int N_length3>
1844
inline
1845
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1846
_bz_VecExpr<P_expr2>,
1847
TinyVectorIterConst<P_numtype3, N_length3> > >
1848
where(_bz_VecExpr<P_expr1> d1,
1849
_bz_VecExpr<P_expr2> d2,
1850
const TinyVector<P_numtype3, N_length3>& d3)
1851
{
1852
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1853
_bz_VecExpr<P_expr2>,
1854
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
1855
1856
return _bz_VecExpr<T_expr>(T_expr(d1,
1857
d2,
1858
d3.beginFast()));
1859
}
1860
1861
// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, int)
1862
template<class P_expr1, class P_expr2>
1863
inline
1864
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1865
_bz_VecExpr<P_expr2>,
1866
_bz_VecExprConstant<int> > >
1867
where(_bz_VecExpr<P_expr1> d1,
1868
_bz_VecExpr<P_expr2> d2,
1869
int d3)
1870
{
1871
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1872
_bz_VecExpr<P_expr2>,
1873
_bz_VecExprConstant<int> > T_expr;
1874
1875
return _bz_VecExpr<T_expr>(T_expr(d1,
1876
d2,
1877
_bz_VecExprConstant<int>(d3)));
1878
}
1879
1880
// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, float)
1881
template<class P_expr1, class P_expr2>
1882
inline
1883
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1884
_bz_VecExpr<P_expr2>,
1885
_bz_VecExprConstant<float> > >
1886
where(_bz_VecExpr<P_expr1> d1,
1887
_bz_VecExpr<P_expr2> d2,
1888
float d3)
1889
{
1890
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1891
_bz_VecExpr<P_expr2>,
1892
_bz_VecExprConstant<float> > T_expr;
1893
1894
return _bz_VecExpr<T_expr>(T_expr(d1,
1895
d2,
1896
_bz_VecExprConstant<float>(d3)));
1897
}
1898
1899
// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, double)
1900
template<class P_expr1, class P_expr2>
1901
inline
1902
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1903
_bz_VecExpr<P_expr2>,
1904
_bz_VecExprConstant<double> > >
1905
where(_bz_VecExpr<P_expr1> d1,
1906
_bz_VecExpr<P_expr2> d2,
1907
double d3)
1908
{
1909
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1910
_bz_VecExpr<P_expr2>,
1911
_bz_VecExprConstant<double> > T_expr;
1912
1913
return _bz_VecExpr<T_expr>(T_expr(d1,
1914
d2,
1915
_bz_VecExprConstant<double>(d3)));
1916
}
1917
1918
// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, long double)
1919
template<class P_expr1, class P_expr2>
1920
inline
1921
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1922
_bz_VecExpr<P_expr2>,
1923
_bz_VecExprConstant<long double> > >
1924
where(_bz_VecExpr<P_expr1> d1,
1925
_bz_VecExpr<P_expr2> d2,
1926
long double d3)
1927
{
1928
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1929
_bz_VecExpr<P_expr2>,
1930
_bz_VecExprConstant<long double> > T_expr;
1931
1932
return _bz_VecExpr<T_expr>(T_expr(d1,
1933
d2,
1934
_bz_VecExprConstant<long double>(d3)));
1935
}
1936
1937
// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, complex<T3>)
1938
#ifdef BZ_HAVE_COMPLEX
1939
template<class P_expr1, class P_expr2, class T3>
1940
inline
1941
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1942
_bz_VecExpr<P_expr2>,
1943
_bz_VecExprConstant<complex<T3> > > >
1944
where(_bz_VecExpr<P_expr1> d1,
1945
_bz_VecExpr<P_expr2> d2,
1946
complex<T3> d3)
1947
{
1948
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1949
_bz_VecExpr<P_expr2>,
1950
_bz_VecExprConstant<complex<T3> > > T_expr;
1951
1952
return _bz_VecExpr<T_expr>(T_expr(d1,
1953
d2,
1954
_bz_VecExprConstant<complex<T3> > (d3)));
1955
}
1956
#endif // BZ_HAVE_COMPLEX
1957
1958
// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, Vector<P_numtype3>)
1959
template<class P_expr1, class P_numtype2, class P_numtype3>
1960
inline
1961
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1962
VectorPickIterConst<P_numtype2>,
1963
VectorIterConst<P_numtype3> > >
1964
where(_bz_VecExpr<P_expr1> d1,
1965
const VectorPick<P_numtype2>& d2,
1966
const Vector<P_numtype3>& d3)
1967
{
1968
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1969
VectorPickIterConst<P_numtype2>,
1970
VectorIterConst<P_numtype3> > T_expr;
1971
1972
return _bz_VecExpr<T_expr>(T_expr(d1,
1973
d2.beginFast(),
1974
d3.beginFast()));
1975
}
1976
1977
// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, _bz_VecExpr<P_expr3>)
1978
template<class P_expr1, class P_numtype2, class P_expr3>
1979
inline
1980
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
1981
VectorPickIterConst<P_numtype2>,
1982
_bz_VecExpr<P_expr3> > >
1983
where(_bz_VecExpr<P_expr1> d1,
1984
const VectorPick<P_numtype2>& d2,
1985
_bz_VecExpr<P_expr3> d3)
1986
{
1987
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
1988
VectorPickIterConst<P_numtype2>,
1989
_bz_VecExpr<P_expr3> > T_expr;
1990
1991
return _bz_VecExpr<T_expr>(T_expr(d1,
1992
d2.beginFast(),
1993
d3));
1994
}
1995
1996
// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, VectorPick<P_numtype3>)
1997
template<class P_expr1, class P_numtype2, class P_numtype3>
1998
inline
1999
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2000
VectorPickIterConst<P_numtype2>,
2001
VectorPickIterConst<P_numtype3> > >
2002
where(_bz_VecExpr<P_expr1> d1,
2003
const VectorPick<P_numtype2>& d2,
2004
const VectorPick<P_numtype3>& d3)
2005
{
2006
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2007
VectorPickIterConst<P_numtype2>,
2008
VectorPickIterConst<P_numtype3> > T_expr;
2009
2010
return _bz_VecExpr<T_expr>(T_expr(d1,
2011
d2.beginFast(),
2012
d3.beginFast()));
2013
}
2014
2015
// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, Range)
2016
template<class P_expr1, class P_numtype2>
2017
inline
2018
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2019
VectorPickIterConst<P_numtype2>,
2020
Range > >
2021
where(_bz_VecExpr<P_expr1> d1,
2022
const VectorPick<P_numtype2>& d2,
2023
Range d3)
2024
{
2025
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2026
VectorPickIterConst<P_numtype2>,
2027
Range > T_expr;
2028
2029
return _bz_VecExpr<T_expr>(T_expr(d1,
2030
d2.beginFast(),
2031
d3));
2032
}
2033
2034
// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, TinyVector<P_numtype3, N_length3>)
2035
template<class P_expr1, class P_numtype2, class P_numtype3, int N_length3>
2036
inline
2037
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2038
VectorPickIterConst<P_numtype2>,
2039
TinyVectorIterConst<P_numtype3, N_length3> > >
2040
where(_bz_VecExpr<P_expr1> d1,
2041
const VectorPick<P_numtype2>& d2,
2042
const TinyVector<P_numtype3, N_length3>& d3)
2043
{
2044
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2045
VectorPickIterConst<P_numtype2>,
2046
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
2047
2048
return _bz_VecExpr<T_expr>(T_expr(d1,
2049
d2.beginFast(),
2050
d3.beginFast()));
2051
}
2052
2053
// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, int)
2054
template<class P_expr1, class P_numtype2>
2055
inline
2056
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2057
VectorPickIterConst<P_numtype2>,
2058
_bz_VecExprConstant<int> > >
2059
where(_bz_VecExpr<P_expr1> d1,
2060
const VectorPick<P_numtype2>& d2,
2061
int d3)
2062
{
2063
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2064
VectorPickIterConst<P_numtype2>,
2065
_bz_VecExprConstant<int> > T_expr;
2066
2067
return _bz_VecExpr<T_expr>(T_expr(d1,
2068
d2.beginFast(),
2069
_bz_VecExprConstant<int>(d3)));
2070
}
2071
2072
// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, float)
2073
template<class P_expr1, class P_numtype2>
2074
inline
2075
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2076
VectorPickIterConst<P_numtype2>,
2077
_bz_VecExprConstant<float> > >
2078
where(_bz_VecExpr<P_expr1> d1,
2079
const VectorPick<P_numtype2>& d2,
2080
float d3)
2081
{
2082
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2083
VectorPickIterConst<P_numtype2>,
2084
_bz_VecExprConstant<float> > T_expr;
2085
2086
return _bz_VecExpr<T_expr>(T_expr(d1,
2087
d2.beginFast(),
2088
_bz_VecExprConstant<float>(d3)));
2089
}
2090
2091
// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, double)
2092
template<class P_expr1, class P_numtype2>
2093
inline
2094
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2095
VectorPickIterConst<P_numtype2>,
2096
_bz_VecExprConstant<double> > >
2097
where(_bz_VecExpr<P_expr1> d1,
2098
const VectorPick<P_numtype2>& d2,
2099
double d3)
2100
{
2101
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2102
VectorPickIterConst<P_numtype2>,
2103
_bz_VecExprConstant<double> > T_expr;
2104
2105
return _bz_VecExpr<T_expr>(T_expr(d1,
2106
d2.beginFast(),
2107
_bz_VecExprConstant<double>(d3)));
2108
}
2109
2110
// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, long double)
2111
template<class P_expr1, class P_numtype2>
2112
inline
2113
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2114
VectorPickIterConst<P_numtype2>,
2115
_bz_VecExprConstant<long double> > >
2116
where(_bz_VecExpr<P_expr1> d1,
2117
const VectorPick<P_numtype2>& d2,
2118
long double d3)
2119
{
2120
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2121
VectorPickIterConst<P_numtype2>,
2122
_bz_VecExprConstant<long double> > T_expr;
2123
2124
return _bz_VecExpr<T_expr>(T_expr(d1,
2125
d2.beginFast(),
2126
_bz_VecExprConstant<long double>(d3)));
2127
}
2128
2129
// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, complex<T3>)
2130
#ifdef BZ_HAVE_COMPLEX
2131
template<class P_expr1, class P_numtype2, class T3>
2132
inline
2133
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2134
VectorPickIterConst<P_numtype2>,
2135
_bz_VecExprConstant<complex<T3> > > >
2136
where(_bz_VecExpr<P_expr1> d1,
2137
const VectorPick<P_numtype2>& d2,
2138
complex<T3> d3)
2139
{
2140
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2141
VectorPickIterConst<P_numtype2>,
2142
_bz_VecExprConstant<complex<T3> > > T_expr;
2143
2144
return _bz_VecExpr<T_expr>(T_expr(d1,
2145
d2.beginFast(),
2146
_bz_VecExprConstant<complex<T3> > (d3)));
2147
}
2148
#endif // BZ_HAVE_COMPLEX
2149
2150
// where(_bz_VecExpr<P_expr1>, Range, Vector<P_numtype3>)
2151
template<class P_expr1, class P_numtype3>
2152
inline
2153
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2154
Range,
2155
VectorIterConst<P_numtype3> > >
2156
where(_bz_VecExpr<P_expr1> d1,
2157
Range d2,
2158
const Vector<P_numtype3>& d3)
2159
{
2160
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2161
Range,
2162
VectorIterConst<P_numtype3> > T_expr;
2163
2164
return _bz_VecExpr<T_expr>(T_expr(d1,
2165
d2,
2166
d3.beginFast()));
2167
}
2168
2169
// where(_bz_VecExpr<P_expr1>, Range, _bz_VecExpr<P_expr3>)
2170
template<class P_expr1, class P_expr3>
2171
inline
2172
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2173
Range,
2174
_bz_VecExpr<P_expr3> > >
2175
where(_bz_VecExpr<P_expr1> d1,
2176
Range d2,
2177
_bz_VecExpr<P_expr3> d3)
2178
{
2179
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2180
Range,
2181
_bz_VecExpr<P_expr3> > T_expr;
2182
2183
return _bz_VecExpr<T_expr>(T_expr(d1,
2184
d2,
2185
d3));
2186
}
2187
2188
// where(_bz_VecExpr<P_expr1>, Range, VectorPick<P_numtype3>)
2189
template<class P_expr1, class P_numtype3>
2190
inline
2191
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2192
Range,
2193
VectorPickIterConst<P_numtype3> > >
2194
where(_bz_VecExpr<P_expr1> d1,
2195
Range d2,
2196
const VectorPick<P_numtype3>& d3)
2197
{
2198
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2199
Range,
2200
VectorPickIterConst<P_numtype3> > T_expr;
2201
2202
return _bz_VecExpr<T_expr>(T_expr(d1,
2203
d2,
2204
d3.beginFast()));
2205
}
2206
2207
// where(_bz_VecExpr<P_expr1>, Range, Range)
2208
template<class P_expr1>
2209
inline
2210
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2211
Range,
2212
Range > >
2213
where(_bz_VecExpr<P_expr1> d1,
2214
Range d2,
2215
Range d3)
2216
{
2217
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2218
Range,
2219
Range > T_expr;
2220
2221
return _bz_VecExpr<T_expr>(T_expr(d1,
2222
d2,
2223
d3));
2224
}
2225
2226
// where(_bz_VecExpr<P_expr1>, Range, TinyVector<P_numtype3, N_length3>)
2227
template<class P_expr1, class P_numtype3, int N_length3>
2228
inline
2229
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2230
Range,
2231
TinyVectorIterConst<P_numtype3, N_length3> > >
2232
where(_bz_VecExpr<P_expr1> d1,
2233
Range d2,
2234
const TinyVector<P_numtype3, N_length3>& d3)
2235
{
2236
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2237
Range,
2238
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
2239
2240
return _bz_VecExpr<T_expr>(T_expr(d1,
2241
d2,
2242
d3.beginFast()));
2243
}
2244
2245
// where(_bz_VecExpr<P_expr1>, Range, int)
2246
template<class P_expr1>
2247
inline
2248
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2249
Range,
2250
_bz_VecExprConstant<int> > >
2251
where(_bz_VecExpr<P_expr1> d1,
2252
Range d2,
2253
int d3)
2254
{
2255
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2256
Range,
2257
_bz_VecExprConstant<int> > T_expr;
2258
2259
return _bz_VecExpr<T_expr>(T_expr(d1,
2260
d2,
2261
_bz_VecExprConstant<int>(d3)));
2262
}
2263
2264
// where(_bz_VecExpr<P_expr1>, Range, float)
2265
template<class P_expr1>
2266
inline
2267
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2268
Range,
2269
_bz_VecExprConstant<float> > >
2270
where(_bz_VecExpr<P_expr1> d1,
2271
Range d2,
2272
float d3)
2273
{
2274
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2275
Range,
2276
_bz_VecExprConstant<float> > T_expr;
2277
2278
return _bz_VecExpr<T_expr>(T_expr(d1,
2279
d2,
2280
_bz_VecExprConstant<float>(d3)));
2281
}
2282
2283
// where(_bz_VecExpr<P_expr1>, Range, double)
2284
template<class P_expr1>
2285
inline
2286
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2287
Range,
2288
_bz_VecExprConstant<double> > >
2289
where(_bz_VecExpr<P_expr1> d1,
2290
Range d2,
2291
double d3)
2292
{
2293
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2294
Range,
2295
_bz_VecExprConstant<double> > T_expr;
2296
2297
return _bz_VecExpr<T_expr>(T_expr(d1,
2298
d2,
2299
_bz_VecExprConstant<double>(d3)));
2300
}
2301
2302
// where(_bz_VecExpr<P_expr1>, Range, long double)
2303
template<class P_expr1>
2304
inline
2305
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2306
Range,
2307
_bz_VecExprConstant<long double> > >
2308
where(_bz_VecExpr<P_expr1> d1,
2309
Range d2,
2310
long double d3)
2311
{
2312
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2313
Range,
2314
_bz_VecExprConstant<long double> > T_expr;
2315
2316
return _bz_VecExpr<T_expr>(T_expr(d1,
2317
d2,
2318
_bz_VecExprConstant<long double>(d3)));
2319
}
2320
2321
// where(_bz_VecExpr<P_expr1>, Range, complex<T3>)
2322
#ifdef BZ_HAVE_COMPLEX
2323
template<class P_expr1, class T3>
2324
inline
2325
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2326
Range,
2327
_bz_VecExprConstant<complex<T3> > > >
2328
where(_bz_VecExpr<P_expr1> d1,
2329
Range d2,
2330
complex<T3> d3)
2331
{
2332
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2333
Range,
2334
_bz_VecExprConstant<complex<T3> > > T_expr;
2335
2336
return _bz_VecExpr<T_expr>(T_expr(d1,
2337
d2,
2338
_bz_VecExprConstant<complex<T3> > (d3)));
2339
}
2340
#endif // BZ_HAVE_COMPLEX
2341
2342
// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, Vector<P_numtype3>)
2343
template<class P_expr1, class P_numtype2, int N_length2, class P_numtype3>
2344
inline
2345
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2346
TinyVectorIterConst<P_numtype2, N_length2>,
2347
VectorIterConst<P_numtype3> > >
2348
where(_bz_VecExpr<P_expr1> d1,
2349
const TinyVector<P_numtype2, N_length2>& d2,
2350
const Vector<P_numtype3>& d3)
2351
{
2352
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2353
TinyVectorIterConst<P_numtype2, N_length2>,
2354
VectorIterConst<P_numtype3> > T_expr;
2355
2356
return _bz_VecExpr<T_expr>(T_expr(d1,
2357
d2.beginFast(),
2358
d3.beginFast()));
2359
}
2360
2361
// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, _bz_VecExpr<P_expr3>)
2362
template<class P_expr1, class P_numtype2, int N_length2, class P_expr3>
2363
inline
2364
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2365
TinyVectorIterConst<P_numtype2, N_length2>,
2366
_bz_VecExpr<P_expr3> > >
2367
where(_bz_VecExpr<P_expr1> d1,
2368
const TinyVector<P_numtype2, N_length2>& d2,
2369
_bz_VecExpr<P_expr3> d3)
2370
{
2371
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2372
TinyVectorIterConst<P_numtype2, N_length2>,
2373
_bz_VecExpr<P_expr3> > T_expr;
2374
2375
return _bz_VecExpr<T_expr>(T_expr(d1,
2376
d2.beginFast(),
2377
d3));
2378
}
2379
2380
// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, VectorPick<P_numtype3>)
2381
template<class P_expr1, class P_numtype2, int N_length2, class P_numtype3>
2382
inline
2383
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2384
TinyVectorIterConst<P_numtype2, N_length2>,
2385
VectorPickIterConst<P_numtype3> > >
2386
where(_bz_VecExpr<P_expr1> d1,
2387
const TinyVector<P_numtype2, N_length2>& d2,
2388
const VectorPick<P_numtype3>& d3)
2389
{
2390
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2391
TinyVectorIterConst<P_numtype2, N_length2>,
2392
VectorPickIterConst<P_numtype3> > T_expr;
2393
2394
return _bz_VecExpr<T_expr>(T_expr(d1,
2395
d2.beginFast(),
2396
d3.beginFast()));
2397
}
2398
2399
// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, Range)
2400
template<class P_expr1, class P_numtype2, int N_length2>
2401
inline
2402
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2403
TinyVectorIterConst<P_numtype2, N_length2>,
2404
Range > >
2405
where(_bz_VecExpr<P_expr1> d1,
2406
const TinyVector<P_numtype2, N_length2>& d2,
2407
Range d3)
2408
{
2409
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2410
TinyVectorIterConst<P_numtype2, N_length2>,
2411
Range > T_expr;
2412
2413
return _bz_VecExpr<T_expr>(T_expr(d1,
2414
d2.beginFast(),
2415
d3));
2416
}
2417
2418
// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, TinyVector<P_numtype3, N_length3>)
2419
template<class P_expr1, class P_numtype2, int N_length2, class P_numtype3, int N_length3>
2420
inline
2421
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2422
TinyVectorIterConst<P_numtype2, N_length2>,
2423
TinyVectorIterConst<P_numtype3, N_length3> > >
2424
where(_bz_VecExpr<P_expr1> d1,
2425
const TinyVector<P_numtype2, N_length2>& d2,
2426
const TinyVector<P_numtype3, N_length3>& d3)
2427
{
2428
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2429
TinyVectorIterConst<P_numtype2, N_length2>,
2430
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
2431
2432
return _bz_VecExpr<T_expr>(T_expr(d1,
2433
d2.beginFast(),
2434
d3.beginFast()));
2435
}
2436
2437
// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, int)
2438
template<class P_expr1, class P_numtype2, int N_length2>
2439
inline
2440
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2441
TinyVectorIterConst<P_numtype2, N_length2>,
2442
_bz_VecExprConstant<int> > >
2443
where(_bz_VecExpr<P_expr1> d1,
2444
const TinyVector<P_numtype2, N_length2>& d2,
2445
int d3)
2446
{
2447
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2448
TinyVectorIterConst<P_numtype2, N_length2>,
2449
_bz_VecExprConstant<int> > T_expr;
2450
2451
return _bz_VecExpr<T_expr>(T_expr(d1,
2452
d2.beginFast(),
2453
_bz_VecExprConstant<int>(d3)));
2454
}
2455
2456
// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, float)
2457
template<class P_expr1, class P_numtype2, int N_length2>
2458
inline
2459
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2460
TinyVectorIterConst<P_numtype2, N_length2>,
2461
_bz_VecExprConstant<float> > >
2462
where(_bz_VecExpr<P_expr1> d1,
2463
const TinyVector<P_numtype2, N_length2>& d2,
2464
float d3)
2465
{
2466
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2467
TinyVectorIterConst<P_numtype2, N_length2>,
2468
_bz_VecExprConstant<float> > T_expr;
2469
2470
return _bz_VecExpr<T_expr>(T_expr(d1,
2471
d2.beginFast(),
2472
_bz_VecExprConstant<float>(d3)));
2473
}
2474
2475
// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, double)
2476
template<class P_expr1, class P_numtype2, int N_length2>
2477
inline
2478
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2479
TinyVectorIterConst<P_numtype2, N_length2>,
2480
_bz_VecExprConstant<double> > >
2481
where(_bz_VecExpr<P_expr1> d1,
2482
const TinyVector<P_numtype2, N_length2>& d2,
2483
double d3)
2484
{
2485
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2486
TinyVectorIterConst<P_numtype2, N_length2>,
2487
_bz_VecExprConstant<double> > T_expr;
2488
2489
return _bz_VecExpr<T_expr>(T_expr(d1,
2490
d2.beginFast(),
2491
_bz_VecExprConstant<double>(d3)));
2492
}
2493
2494
// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, long double)
2495
template<class P_expr1, class P_numtype2, int N_length2>
2496
inline
2497
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2498
TinyVectorIterConst<P_numtype2, N_length2>,
2499
_bz_VecExprConstant<long double> > >
2500
where(_bz_VecExpr<P_expr1> d1,
2501
const TinyVector<P_numtype2, N_length2>& d2,
2502
long double d3)
2503
{
2504
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2505
TinyVectorIterConst<P_numtype2, N_length2>,
2506
_bz_VecExprConstant<long double> > T_expr;
2507
2508
return _bz_VecExpr<T_expr>(T_expr(d1,
2509
d2.beginFast(),
2510
_bz_VecExprConstant<long double>(d3)));
2511
}
2512
2513
// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, complex<T3>)
2514
#ifdef BZ_HAVE_COMPLEX
2515
template<class P_expr1, class P_numtype2, int N_length2, class T3>
2516
inline
2517
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2518
TinyVectorIterConst<P_numtype2, N_length2>,
2519
_bz_VecExprConstant<complex<T3> > > >
2520
where(_bz_VecExpr<P_expr1> d1,
2521
const TinyVector<P_numtype2, N_length2>& d2,
2522
complex<T3> d3)
2523
{
2524
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2525
TinyVectorIterConst<P_numtype2, N_length2>,
2526
_bz_VecExprConstant<complex<T3> > > T_expr;
2527
2528
return _bz_VecExpr<T_expr>(T_expr(d1,
2529
d2.beginFast(),
2530
_bz_VecExprConstant<complex<T3> > (d3)));
2531
}
2532
#endif // BZ_HAVE_COMPLEX
2533
2534
// where(_bz_VecExpr<P_expr1>, int, Vector<P_numtype3>)
2535
template<class P_expr1, class P_numtype3>
2536
inline
2537
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2538
_bz_VecExprConstant<int>,
2539
VectorIterConst<P_numtype3> > >
2540
where(_bz_VecExpr<P_expr1> d1,
2541
int d2,
2542
const Vector<P_numtype3>& d3)
2543
{
2544
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2545
_bz_VecExprConstant<int>,
2546
VectorIterConst<P_numtype3> > T_expr;
2547
2548
return _bz_VecExpr<T_expr>(T_expr(d1,
2549
_bz_VecExprConstant<int>(d2),
2550
d3.beginFast()));
2551
}
2552
2553
// where(_bz_VecExpr<P_expr1>, int, _bz_VecExpr<P_expr3>)
2554
template<class P_expr1, class P_expr3>
2555
inline
2556
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2557
_bz_VecExprConstant<int>,
2558
_bz_VecExpr<P_expr3> > >
2559
where(_bz_VecExpr<P_expr1> d1,
2560
int d2,
2561
_bz_VecExpr<P_expr3> d3)
2562
{
2563
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2564
_bz_VecExprConstant<int>,
2565
_bz_VecExpr<P_expr3> > T_expr;
2566
2567
return _bz_VecExpr<T_expr>(T_expr(d1,
2568
_bz_VecExprConstant<int>(d2),
2569
d3));
2570
}
2571
2572
// where(_bz_VecExpr<P_expr1>, int, VectorPick<P_numtype3>)
2573
template<class P_expr1, class P_numtype3>
2574
inline
2575
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2576
_bz_VecExprConstant<int>,
2577
VectorPickIterConst<P_numtype3> > >
2578
where(_bz_VecExpr<P_expr1> d1,
2579
int d2,
2580
const VectorPick<P_numtype3>& d3)
2581
{
2582
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2583
_bz_VecExprConstant<int>,
2584
VectorPickIterConst<P_numtype3> > T_expr;
2585
2586
return _bz_VecExpr<T_expr>(T_expr(d1,
2587
_bz_VecExprConstant<int>(d2),
2588
d3.beginFast()));
2589
}
2590
2591
// where(_bz_VecExpr<P_expr1>, int, Range)
2592
template<class P_expr1>
2593
inline
2594
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2595
_bz_VecExprConstant<int>,
2596
Range > >
2597
where(_bz_VecExpr<P_expr1> d1,
2598
int d2,
2599
Range d3)
2600
{
2601
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2602
_bz_VecExprConstant<int>,
2603
Range > T_expr;
2604
2605
return _bz_VecExpr<T_expr>(T_expr(d1,
2606
_bz_VecExprConstant<int>(d2),
2607
d3));
2608
}
2609
2610
// where(_bz_VecExpr<P_expr1>, int, TinyVector<P_numtype3, N_length3>)
2611
template<class P_expr1, class P_numtype3, int N_length3>
2612
inline
2613
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2614
_bz_VecExprConstant<int>,
2615
TinyVectorIterConst<P_numtype3, N_length3> > >
2616
where(_bz_VecExpr<P_expr1> d1,
2617
int d2,
2618
const TinyVector<P_numtype3, N_length3>& d3)
2619
{
2620
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2621
_bz_VecExprConstant<int>,
2622
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
2623
2624
return _bz_VecExpr<T_expr>(T_expr(d1,
2625
_bz_VecExprConstant<int>(d2),
2626
d3.beginFast()));
2627
}
2628
2629
// where(_bz_VecExpr<P_expr1>, int, int)
2630
template<class P_expr1>
2631
inline
2632
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2633
_bz_VecExprConstant<int>,
2634
_bz_VecExprConstant<int> > >
2635
where(_bz_VecExpr<P_expr1> d1,
2636
int d2,
2637
int d3)
2638
{
2639
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2640
_bz_VecExprConstant<int>,
2641
_bz_VecExprConstant<int> > T_expr;
2642
2643
return _bz_VecExpr<T_expr>(T_expr(d1,
2644
_bz_VecExprConstant<int>(d2),
2645
_bz_VecExprConstant<int>(d3)));
2646
}
2647
2648
// where(_bz_VecExpr<P_expr1>, float, Vector<P_numtype3>)
2649
template<class P_expr1, class P_numtype3>
2650
inline
2651
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2652
_bz_VecExprConstant<float>,
2653
VectorIterConst<P_numtype3> > >
2654
where(_bz_VecExpr<P_expr1> d1,
2655
float d2,
2656
const Vector<P_numtype3>& d3)
2657
{
2658
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2659
_bz_VecExprConstant<float>,
2660
VectorIterConst<P_numtype3> > T_expr;
2661
2662
return _bz_VecExpr<T_expr>(T_expr(d1,
2663
_bz_VecExprConstant<float>(d2),
2664
d3.beginFast()));
2665
}
2666
2667
// where(_bz_VecExpr<P_expr1>, float, _bz_VecExpr<P_expr3>)
2668
template<class P_expr1, class P_expr3>
2669
inline
2670
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2671
_bz_VecExprConstant<float>,
2672
_bz_VecExpr<P_expr3> > >
2673
where(_bz_VecExpr<P_expr1> d1,
2674
float d2,
2675
_bz_VecExpr<P_expr3> d3)
2676
{
2677
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2678
_bz_VecExprConstant<float>,
2679
_bz_VecExpr<P_expr3> > T_expr;
2680
2681
return _bz_VecExpr<T_expr>(T_expr(d1,
2682
_bz_VecExprConstant<float>(d2),
2683
d3));
2684
}
2685
2686
// where(_bz_VecExpr<P_expr1>, float, VectorPick<P_numtype3>)
2687
template<class P_expr1, class P_numtype3>
2688
inline
2689
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2690
_bz_VecExprConstant<float>,
2691
VectorPickIterConst<P_numtype3> > >
2692
where(_bz_VecExpr<P_expr1> d1,
2693
float d2,
2694
const VectorPick<P_numtype3>& d3)
2695
{
2696
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2697
_bz_VecExprConstant<float>,
2698
VectorPickIterConst<P_numtype3> > T_expr;
2699
2700
return _bz_VecExpr<T_expr>(T_expr(d1,
2701
_bz_VecExprConstant<float>(d2),
2702
d3.beginFast()));
2703
}
2704
2705
// where(_bz_VecExpr<P_expr1>, float, Range)
2706
template<class P_expr1>
2707
inline
2708
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2709
_bz_VecExprConstant<float>,
2710
Range > >
2711
where(_bz_VecExpr<P_expr1> d1,
2712
float d2,
2713
Range d3)
2714
{
2715
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2716
_bz_VecExprConstant<float>,
2717
Range > T_expr;
2718
2719
return _bz_VecExpr<T_expr>(T_expr(d1,
2720
_bz_VecExprConstant<float>(d2),
2721
d3));
2722
}
2723
2724
// where(_bz_VecExpr<P_expr1>, float, TinyVector<P_numtype3, N_length3>)
2725
template<class P_expr1, class P_numtype3, int N_length3>
2726
inline
2727
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2728
_bz_VecExprConstant<float>,
2729
TinyVectorIterConst<P_numtype3, N_length3> > >
2730
where(_bz_VecExpr<P_expr1> d1,
2731
float d2,
2732
const TinyVector<P_numtype3, N_length3>& d3)
2733
{
2734
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2735
_bz_VecExprConstant<float>,
2736
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
2737
2738
return _bz_VecExpr<T_expr>(T_expr(d1,
2739
_bz_VecExprConstant<float>(d2),
2740
d3.beginFast()));
2741
}
2742
2743
// where(_bz_VecExpr<P_expr1>, float, float)
2744
template<class P_expr1>
2745
inline
2746
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2747
_bz_VecExprConstant<float>,
2748
_bz_VecExprConstant<float> > >
2749
where(_bz_VecExpr<P_expr1> d1,
2750
float d2,
2751
float d3)
2752
{
2753
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2754
_bz_VecExprConstant<float>,
2755
_bz_VecExprConstant<float> > T_expr;
2756
2757
return _bz_VecExpr<T_expr>(T_expr(d1,
2758
_bz_VecExprConstant<float>(d2),
2759
_bz_VecExprConstant<float>(d3)));
2760
}
2761
2762
// where(_bz_VecExpr<P_expr1>, double, Vector<P_numtype3>)
2763
template<class P_expr1, class P_numtype3>
2764
inline
2765
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2766
_bz_VecExprConstant<double>,
2767
VectorIterConst<P_numtype3> > >
2768
where(_bz_VecExpr<P_expr1> d1,
2769
double d2,
2770
const Vector<P_numtype3>& d3)
2771
{
2772
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2773
_bz_VecExprConstant<double>,
2774
VectorIterConst<P_numtype3> > T_expr;
2775
2776
return _bz_VecExpr<T_expr>(T_expr(d1,
2777
_bz_VecExprConstant<double>(d2),
2778
d3.beginFast()));
2779
}
2780
2781
// where(_bz_VecExpr<P_expr1>, double, _bz_VecExpr<P_expr3>)
2782
template<class P_expr1, class P_expr3>
2783
inline
2784
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2785
_bz_VecExprConstant<double>,
2786
_bz_VecExpr<P_expr3> > >
2787
where(_bz_VecExpr<P_expr1> d1,
2788
double d2,
2789
_bz_VecExpr<P_expr3> d3)
2790
{
2791
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2792
_bz_VecExprConstant<double>,
2793
_bz_VecExpr<P_expr3> > T_expr;
2794
2795
return _bz_VecExpr<T_expr>(T_expr(d1,
2796
_bz_VecExprConstant<double>(d2),
2797
d3));
2798
}
2799
2800
// where(_bz_VecExpr<P_expr1>, double, VectorPick<P_numtype3>)
2801
template<class P_expr1, class P_numtype3>
2802
inline
2803
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2804
_bz_VecExprConstant<double>,
2805
VectorPickIterConst<P_numtype3> > >
2806
where(_bz_VecExpr<P_expr1> d1,
2807
double d2,
2808
const VectorPick<P_numtype3>& d3)
2809
{
2810
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2811
_bz_VecExprConstant<double>,
2812
VectorPickIterConst<P_numtype3> > T_expr;
2813
2814
return _bz_VecExpr<T_expr>(T_expr(d1,
2815
_bz_VecExprConstant<double>(d2),
2816
d3.beginFast()));
2817
}
2818
2819
// where(_bz_VecExpr<P_expr1>, double, Range)
2820
template<class P_expr1>
2821
inline
2822
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2823
_bz_VecExprConstant<double>,
2824
Range > >
2825
where(_bz_VecExpr<P_expr1> d1,
2826
double d2,
2827
Range d3)
2828
{
2829
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2830
_bz_VecExprConstant<double>,
2831
Range > T_expr;
2832
2833
return _bz_VecExpr<T_expr>(T_expr(d1,
2834
_bz_VecExprConstant<double>(d2),
2835
d3));
2836
}
2837
2838
// where(_bz_VecExpr<P_expr1>, double, TinyVector<P_numtype3, N_length3>)
2839
template<class P_expr1, class P_numtype3, int N_length3>
2840
inline
2841
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2842
_bz_VecExprConstant<double>,
2843
TinyVectorIterConst<P_numtype3, N_length3> > >
2844
where(_bz_VecExpr<P_expr1> d1,
2845
double d2,
2846
const TinyVector<P_numtype3, N_length3>& d3)
2847
{
2848
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2849
_bz_VecExprConstant<double>,
2850
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
2851
2852
return _bz_VecExpr<T_expr>(T_expr(d1,
2853
_bz_VecExprConstant<double>(d2),
2854
d3.beginFast()));
2855
}
2856
2857
// where(_bz_VecExpr<P_expr1>, double, double)
2858
template<class P_expr1>
2859
inline
2860
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2861
_bz_VecExprConstant<double>,
2862
_bz_VecExprConstant<double> > >
2863
where(_bz_VecExpr<P_expr1> d1,
2864
double d2,
2865
double d3)
2866
{
2867
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2868
_bz_VecExprConstant<double>,
2869
_bz_VecExprConstant<double> > T_expr;
2870
2871
return _bz_VecExpr<T_expr>(T_expr(d1,
2872
_bz_VecExprConstant<double>(d2),
2873
_bz_VecExprConstant<double>(d3)));
2874
}
2875
2876
// where(_bz_VecExpr<P_expr1>, long double, Vector<P_numtype3>)
2877
template<class P_expr1, class P_numtype3>
2878
inline
2879
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2880
_bz_VecExprConstant<long double>,
2881
VectorIterConst<P_numtype3> > >
2882
where(_bz_VecExpr<P_expr1> d1,
2883
long double d2,
2884
const Vector<P_numtype3>& d3)
2885
{
2886
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2887
_bz_VecExprConstant<long double>,
2888
VectorIterConst<P_numtype3> > T_expr;
2889
2890
return _bz_VecExpr<T_expr>(T_expr(d1,
2891
_bz_VecExprConstant<long double>(d2),
2892
d3.beginFast()));
2893
}
2894
2895
// where(_bz_VecExpr<P_expr1>, long double, _bz_VecExpr<P_expr3>)
2896
template<class P_expr1, class P_expr3>
2897
inline
2898
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2899
_bz_VecExprConstant<long double>,
2900
_bz_VecExpr<P_expr3> > >
2901
where(_bz_VecExpr<P_expr1> d1,
2902
long double d2,
2903
_bz_VecExpr<P_expr3> d3)
2904
{
2905
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2906
_bz_VecExprConstant<long double>,
2907
_bz_VecExpr<P_expr3> > T_expr;
2908
2909
return _bz_VecExpr<T_expr>(T_expr(d1,
2910
_bz_VecExprConstant<long double>(d2),
2911
d3));
2912
}
2913
2914
// where(_bz_VecExpr<P_expr1>, long double, VectorPick<P_numtype3>)
2915
template<class P_expr1, class P_numtype3>
2916
inline
2917
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2918
_bz_VecExprConstant<long double>,
2919
VectorPickIterConst<P_numtype3> > >
2920
where(_bz_VecExpr<P_expr1> d1,
2921
long double d2,
2922
const VectorPick<P_numtype3>& d3)
2923
{
2924
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2925
_bz_VecExprConstant<long double>,
2926
VectorPickIterConst<P_numtype3> > T_expr;
2927
2928
return _bz_VecExpr<T_expr>(T_expr(d1,
2929
_bz_VecExprConstant<long double>(d2),
2930
d3.beginFast()));
2931
}
2932
2933
// where(_bz_VecExpr<P_expr1>, long double, Range)
2934
template<class P_expr1>
2935
inline
2936
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2937
_bz_VecExprConstant<long double>,
2938
Range > >
2939
where(_bz_VecExpr<P_expr1> d1,
2940
long double d2,
2941
Range d3)
2942
{
2943
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2944
_bz_VecExprConstant<long double>,
2945
Range > T_expr;
2946
2947
return _bz_VecExpr<T_expr>(T_expr(d1,
2948
_bz_VecExprConstant<long double>(d2),
2949
d3));
2950
}
2951
2952
// where(_bz_VecExpr<P_expr1>, long double, TinyVector<P_numtype3, N_length3>)
2953
template<class P_expr1, class P_numtype3, int N_length3>
2954
inline
2955
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2956
_bz_VecExprConstant<long double>,
2957
TinyVectorIterConst<P_numtype3, N_length3> > >
2958
where(_bz_VecExpr<P_expr1> d1,
2959
long double d2,
2960
const TinyVector<P_numtype3, N_length3>& d3)
2961
{
2962
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2963
_bz_VecExprConstant<long double>,
2964
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
2965
2966
return _bz_VecExpr<T_expr>(T_expr(d1,
2967
_bz_VecExprConstant<long double>(d2),
2968
d3.beginFast()));
2969
}
2970
2971
// where(_bz_VecExpr<P_expr1>, long double, long double)
2972
template<class P_expr1>
2973
inline
2974
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2975
_bz_VecExprConstant<long double>,
2976
_bz_VecExprConstant<long double> > >
2977
where(_bz_VecExpr<P_expr1> d1,
2978
long double d2,
2979
long double d3)
2980
{
2981
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
2982
_bz_VecExprConstant<long double>,
2983
_bz_VecExprConstant<long double> > T_expr;
2984
2985
return _bz_VecExpr<T_expr>(T_expr(d1,
2986
_bz_VecExprConstant<long double>(d2),
2987
_bz_VecExprConstant<long double>(d3)));
2988
}
2989
2990
// where(_bz_VecExpr<P_expr1>, complex<T2>, Vector<P_numtype3>)
2991
#ifdef BZ_HAVE_COMPLEX
2992
template<class P_expr1, class T2, class P_numtype3>
2993
inline
2994
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
2995
_bz_VecExprConstant<complex<T2> > ,
2996
VectorIterConst<P_numtype3> > >
2997
where(_bz_VecExpr<P_expr1> d1,
2998
complex<T2> d2,
2999
const Vector<P_numtype3>& d3)
3000
{
3001
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
3002
_bz_VecExprConstant<complex<T2> > ,
3003
VectorIterConst<P_numtype3> > T_expr;
3004
3005
return _bz_VecExpr<T_expr>(T_expr(d1,
3006
_bz_VecExprConstant<complex<T2> > (d2),
3007
d3.beginFast()));
3008
}
3009
#endif // BZ_HAVE_COMPLEX
3010
3011
// where(_bz_VecExpr<P_expr1>, complex<T2>, _bz_VecExpr<P_expr3>)
3012
#ifdef BZ_HAVE_COMPLEX
3013
template<class P_expr1, class T2, class P_expr3>
3014
inline
3015
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
3016
_bz_VecExprConstant<complex<T2> > ,
3017
_bz_VecExpr<P_expr3> > >
3018
where(_bz_VecExpr<P_expr1> d1,
3019
complex<T2> d2,
3020
_bz_VecExpr<P_expr3> d3)
3021
{
3022
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
3023
_bz_VecExprConstant<complex<T2> > ,
3024
_bz_VecExpr<P_expr3> > T_expr;
3025
3026
return _bz_VecExpr<T_expr>(T_expr(d1,
3027
_bz_VecExprConstant<complex<T2> > (d2),
3028
d3));
3029
}
3030
#endif // BZ_HAVE_COMPLEX
3031
3032
// where(_bz_VecExpr<P_expr1>, complex<T2>, VectorPick<P_numtype3>)
3033
#ifdef BZ_HAVE_COMPLEX
3034
template<class P_expr1, class T2, class P_numtype3>
3035
inline
3036
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
3037
_bz_VecExprConstant<complex<T2> > ,
3038
VectorPickIterConst<P_numtype3> > >
3039
where(_bz_VecExpr<P_expr1> d1,
3040
complex<T2> d2,
3041
const VectorPick<P_numtype3>& d3)
3042
{
3043
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
3044
_bz_VecExprConstant<complex<T2> > ,
3045
VectorPickIterConst<P_numtype3> > T_expr;
3046
3047
return _bz_VecExpr<T_expr>(T_expr(d1,
3048
_bz_VecExprConstant<complex<T2> > (d2),
3049
d3.beginFast()));
3050
}
3051
#endif // BZ_HAVE_COMPLEX
3052
3053
// where(_bz_VecExpr<P_expr1>, complex<T2>, Range)
3054
#ifdef BZ_HAVE_COMPLEX
3055
template<class P_expr1, class T2>
3056
inline
3057
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
3058
_bz_VecExprConstant<complex<T2> > ,
3059
Range > >
3060
where(_bz_VecExpr<P_expr1> d1,
3061
complex<T2> d2,
3062
Range d3)
3063
{
3064
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
3065
_bz_VecExprConstant<complex<T2> > ,
3066
Range > T_expr;
3067
3068
return _bz_VecExpr<T_expr>(T_expr(d1,
3069
_bz_VecExprConstant<complex<T2> > (d2),
3070
d3));
3071
}
3072
#endif // BZ_HAVE_COMPLEX
3073
3074
// where(_bz_VecExpr<P_expr1>, complex<T2>, TinyVector<P_numtype3, N_length3>)
3075
#ifdef BZ_HAVE_COMPLEX
3076
template<class P_expr1, class T2, class P_numtype3, int N_length3>
3077
inline
3078
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
3079
_bz_VecExprConstant<complex<T2> > ,
3080
TinyVectorIterConst<P_numtype3, N_length3> > >
3081
where(_bz_VecExpr<P_expr1> d1,
3082
complex<T2> d2,
3083
const TinyVector<P_numtype3, N_length3>& d3)
3084
{
3085
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
3086
_bz_VecExprConstant<complex<T2> > ,
3087
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
3088
3089
return _bz_VecExpr<T_expr>(T_expr(d1,
3090
_bz_VecExprConstant<complex<T2> > (d2),
3091
d3.beginFast()));
3092
}
3093
#endif // BZ_HAVE_COMPLEX
3094
3095
// where(_bz_VecExpr<P_expr1>, complex<T2>, complex<T3>)
3096
#ifdef BZ_HAVE_COMPLEX
3097
template<class P_expr1, class T2, class T3>
3098
inline
3099
_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>,
3100
_bz_VecExprConstant<complex<T2> > ,
3101
_bz_VecExprConstant<complex<T3> > > >
3102
where(_bz_VecExpr<P_expr1> d1,
3103
complex<T2> d2,
3104
complex<T3> d3)
3105
{
3106
typedef _bz_VecWhere<_bz_VecExpr<P_expr1>,
3107
_bz_VecExprConstant<complex<T2> > ,
3108
_bz_VecExprConstant<complex<T3> > > T_expr;
3109
3110
return _bz_VecExpr<T_expr>(T_expr(d1,
3111
_bz_VecExprConstant<complex<T2> > (d2),
3112
_bz_VecExprConstant<complex<T3> > (d3)));
3113
}
3114
#endif // BZ_HAVE_COMPLEX
3115
3116
// where(VectorPick<P_numtype1>, Vector<P_numtype2>, Vector<P_numtype3>)
3117
template<class P_numtype1, class P_numtype2, class P_numtype3>
3118
inline
3119
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3120
VectorIterConst<P_numtype2>,
3121
VectorIterConst<P_numtype3> > >
3122
where(const VectorPick<P_numtype1>& d1,
3123
const Vector<P_numtype2>& d2,
3124
const Vector<P_numtype3>& d3)
3125
{
3126
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3127
VectorIterConst<P_numtype2>,
3128
VectorIterConst<P_numtype3> > T_expr;
3129
3130
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3131
d2.beginFast(),
3132
d3.beginFast()));
3133
}
3134
3135
// where(VectorPick<P_numtype1>, Vector<P_numtype2>, _bz_VecExpr<P_expr3>)
3136
template<class P_numtype1, class P_numtype2, class P_expr3>
3137
inline
3138
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3139
VectorIterConst<P_numtype2>,
3140
_bz_VecExpr<P_expr3> > >
3141
where(const VectorPick<P_numtype1>& d1,
3142
const Vector<P_numtype2>& d2,
3143
_bz_VecExpr<P_expr3> d3)
3144
{
3145
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3146
VectorIterConst<P_numtype2>,
3147
_bz_VecExpr<P_expr3> > T_expr;
3148
3149
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3150
d2.beginFast(),
3151
d3));
3152
}
3153
3154
// where(VectorPick<P_numtype1>, Vector<P_numtype2>, VectorPick<P_numtype3>)
3155
template<class P_numtype1, class P_numtype2, class P_numtype3>
3156
inline
3157
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3158
VectorIterConst<P_numtype2>,
3159
VectorPickIterConst<P_numtype3> > >
3160
where(const VectorPick<P_numtype1>& d1,
3161
const Vector<P_numtype2>& d2,
3162
const VectorPick<P_numtype3>& d3)
3163
{
3164
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3165
VectorIterConst<P_numtype2>,
3166
VectorPickIterConst<P_numtype3> > T_expr;
3167
3168
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3169
d2.beginFast(),
3170
d3.beginFast()));
3171
}
3172
3173
// where(VectorPick<P_numtype1>, Vector<P_numtype2>, Range)
3174
template<class P_numtype1, class P_numtype2>
3175
inline
3176
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3177
VectorIterConst<P_numtype2>,
3178
Range > >
3179
where(const VectorPick<P_numtype1>& d1,
3180
const Vector<P_numtype2>& d2,
3181
Range d3)
3182
{
3183
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3184
VectorIterConst<P_numtype2>,
3185
Range > T_expr;
3186
3187
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3188
d2.beginFast(),
3189
d3));
3190
}
3191
3192
// where(VectorPick<P_numtype1>, Vector<P_numtype2>, TinyVector<P_numtype3, N_length3>)
3193
template<class P_numtype1, class P_numtype2, class P_numtype3, int N_length3>
3194
inline
3195
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3196
VectorIterConst<P_numtype2>,
3197
TinyVectorIterConst<P_numtype3, N_length3> > >
3198
where(const VectorPick<P_numtype1>& d1,
3199
const Vector<P_numtype2>& d2,
3200
const TinyVector<P_numtype3, N_length3>& d3)
3201
{
3202
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3203
VectorIterConst<P_numtype2>,
3204
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
3205
3206
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3207
d2.beginFast(),
3208
d3.beginFast()));
3209
}
3210
3211
// where(VectorPick<P_numtype1>, Vector<P_numtype2>, int)
3212
template<class P_numtype1, class P_numtype2>
3213
inline
3214
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3215
VectorIterConst<P_numtype2>,
3216
_bz_VecExprConstant<int> > >
3217
where(const VectorPick<P_numtype1>& d1,
3218
const Vector<P_numtype2>& d2,
3219
int d3)
3220
{
3221
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3222
VectorIterConst<P_numtype2>,
3223
_bz_VecExprConstant<int> > T_expr;
3224
3225
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3226
d2.beginFast(),
3227
_bz_VecExprConstant<int>(d3)));
3228
}
3229
3230
// where(VectorPick<P_numtype1>, Vector<P_numtype2>, float)
3231
template<class P_numtype1, class P_numtype2>
3232
inline
3233
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3234
VectorIterConst<P_numtype2>,
3235
_bz_VecExprConstant<float> > >
3236
where(const VectorPick<P_numtype1>& d1,
3237
const Vector<P_numtype2>& d2,
3238
float d3)
3239
{
3240
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3241
VectorIterConst<P_numtype2>,
3242
_bz_VecExprConstant<float> > T_expr;
3243
3244
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3245
d2.beginFast(),
3246
_bz_VecExprConstant<float>(d3)));
3247
}
3248
3249
// where(VectorPick<P_numtype1>, Vector<P_numtype2>, double)
3250
template<class P_numtype1, class P_numtype2>
3251
inline
3252
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3253
VectorIterConst<P_numtype2>,
3254
_bz_VecExprConstant<double> > >
3255
where(const VectorPick<P_numtype1>& d1,
3256
const Vector<P_numtype2>& d2,
3257
double d3)
3258
{
3259
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3260
VectorIterConst<P_numtype2>,
3261
_bz_VecExprConstant<double> > T_expr;
3262
3263
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3264
d2.beginFast(),
3265
_bz_VecExprConstant<double>(d3)));
3266
}
3267
3268
// where(VectorPick<P_numtype1>, Vector<P_numtype2>, long double)
3269
template<class P_numtype1, class P_numtype2>
3270
inline
3271
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3272
VectorIterConst<P_numtype2>,
3273
_bz_VecExprConstant<long double> > >
3274
where(const VectorPick<P_numtype1>& d1,
3275
const Vector<P_numtype2>& d2,
3276
long double d3)
3277
{
3278
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3279
VectorIterConst<P_numtype2>,
3280
_bz_VecExprConstant<long double> > T_expr;
3281
3282
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3283
d2.beginFast(),
3284
_bz_VecExprConstant<long double>(d3)));
3285
}
3286
3287
// where(VectorPick<P_numtype1>, Vector<P_numtype2>, complex<T3>)
3288
#ifdef BZ_HAVE_COMPLEX
3289
template<class P_numtype1, class P_numtype2, class T3>
3290
inline
3291
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3292
VectorIterConst<P_numtype2>,
3293
_bz_VecExprConstant<complex<T3> > > >
3294
where(const VectorPick<P_numtype1>& d1,
3295
const Vector<P_numtype2>& d2,
3296
complex<T3> d3)
3297
{
3298
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3299
VectorIterConst<P_numtype2>,
3300
_bz_VecExprConstant<complex<T3> > > T_expr;
3301
3302
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3303
d2.beginFast(),
3304
_bz_VecExprConstant<complex<T3> > (d3)));
3305
}
3306
#endif // BZ_HAVE_COMPLEX
3307
3308
// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, Vector<P_numtype3>)
3309
template<class P_numtype1, class P_expr2, class P_numtype3>
3310
inline
3311
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3312
_bz_VecExpr<P_expr2>,
3313
VectorIterConst<P_numtype3> > >
3314
where(const VectorPick<P_numtype1>& d1,
3315
_bz_VecExpr<P_expr2> d2,
3316
const Vector<P_numtype3>& d3)
3317
{
3318
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3319
_bz_VecExpr<P_expr2>,
3320
VectorIterConst<P_numtype3> > T_expr;
3321
3322
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3323
d2,
3324
d3.beginFast()));
3325
}
3326
3327
// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, _bz_VecExpr<P_expr3>)
3328
template<class P_numtype1, class P_expr2, class P_expr3>
3329
inline
3330
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3331
_bz_VecExpr<P_expr2>,
3332
_bz_VecExpr<P_expr3> > >
3333
where(const VectorPick<P_numtype1>& d1,
3334
_bz_VecExpr<P_expr2> d2,
3335
_bz_VecExpr<P_expr3> d3)
3336
{
3337
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3338
_bz_VecExpr<P_expr2>,
3339
_bz_VecExpr<P_expr3> > T_expr;
3340
3341
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3342
d2,
3343
d3));
3344
}
3345
3346
// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, VectorPick<P_numtype3>)
3347
template<class P_numtype1, class P_expr2, class P_numtype3>
3348
inline
3349
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3350
_bz_VecExpr<P_expr2>,
3351
VectorPickIterConst<P_numtype3> > >
3352
where(const VectorPick<P_numtype1>& d1,
3353
_bz_VecExpr<P_expr2> d2,
3354
const VectorPick<P_numtype3>& d3)
3355
{
3356
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3357
_bz_VecExpr<P_expr2>,
3358
VectorPickIterConst<P_numtype3> > T_expr;
3359
3360
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3361
d2,
3362
d3.beginFast()));
3363
}
3364
3365
// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, Range)
3366
template<class P_numtype1, class P_expr2>
3367
inline
3368
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3369
_bz_VecExpr<P_expr2>,
3370
Range > >
3371
where(const VectorPick<P_numtype1>& d1,
3372
_bz_VecExpr<P_expr2> d2,
3373
Range d3)
3374
{
3375
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3376
_bz_VecExpr<P_expr2>,
3377
Range > T_expr;
3378
3379
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3380
d2,
3381
d3));
3382
}
3383
3384
// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, TinyVector<P_numtype3, N_length3>)
3385
template<class P_numtype1, class P_expr2, class P_numtype3, int N_length3>
3386
inline
3387
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3388
_bz_VecExpr<P_expr2>,
3389
TinyVectorIterConst<P_numtype3, N_length3> > >
3390
where(const VectorPick<P_numtype1>& d1,
3391
_bz_VecExpr<P_expr2> d2,
3392
const TinyVector<P_numtype3, N_length3>& d3)
3393
{
3394
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3395
_bz_VecExpr<P_expr2>,
3396
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
3397
3398
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3399
d2,
3400
d3.beginFast()));
3401
}
3402
3403
// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, int)
3404
template<class P_numtype1, class P_expr2>
3405
inline
3406
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3407
_bz_VecExpr<P_expr2>,
3408
_bz_VecExprConstant<int> > >
3409
where(const VectorPick<P_numtype1>& d1,
3410
_bz_VecExpr<P_expr2> d2,
3411
int d3)
3412
{
3413
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3414
_bz_VecExpr<P_expr2>,
3415
_bz_VecExprConstant<int> > T_expr;
3416
3417
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3418
d2,
3419
_bz_VecExprConstant<int>(d3)));
3420
}
3421
3422
// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, float)
3423
template<class P_numtype1, class P_expr2>
3424
inline
3425
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3426
_bz_VecExpr<P_expr2>,
3427
_bz_VecExprConstant<float> > >
3428
where(const VectorPick<P_numtype1>& d1,
3429
_bz_VecExpr<P_expr2> d2,
3430
float d3)
3431
{
3432
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3433
_bz_VecExpr<P_expr2>,
3434
_bz_VecExprConstant<float> > T_expr;
3435
3436
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3437
d2,
3438
_bz_VecExprConstant<float>(d3)));
3439
}
3440
3441
// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, double)
3442
template<class P_numtype1, class P_expr2>
3443
inline
3444
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3445
_bz_VecExpr<P_expr2>,
3446
_bz_VecExprConstant<double> > >
3447
where(const VectorPick<P_numtype1>& d1,
3448
_bz_VecExpr<P_expr2> d2,
3449
double d3)
3450
{
3451
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3452
_bz_VecExpr<P_expr2>,
3453
_bz_VecExprConstant<double> > T_expr;
3454
3455
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3456
d2,
3457
_bz_VecExprConstant<double>(d3)));
3458
}
3459
3460
// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, long double)
3461
template<class P_numtype1, class P_expr2>
3462
inline
3463
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3464
_bz_VecExpr<P_expr2>,
3465
_bz_VecExprConstant<long double> > >
3466
where(const VectorPick<P_numtype1>& d1,
3467
_bz_VecExpr<P_expr2> d2,
3468
long double d3)
3469
{
3470
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3471
_bz_VecExpr<P_expr2>,
3472
_bz_VecExprConstant<long double> > T_expr;
3473
3474
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3475
d2,
3476
_bz_VecExprConstant<long double>(d3)));
3477
}
3478
3479
// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, complex<T3>)
3480
#ifdef BZ_HAVE_COMPLEX
3481
template<class P_numtype1, class P_expr2, class T3>
3482
inline
3483
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3484
_bz_VecExpr<P_expr2>,
3485
_bz_VecExprConstant<complex<T3> > > >
3486
where(const VectorPick<P_numtype1>& d1,
3487
_bz_VecExpr<P_expr2> d2,
3488
complex<T3> d3)
3489
{
3490
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3491
_bz_VecExpr<P_expr2>,
3492
_bz_VecExprConstant<complex<T3> > > T_expr;
3493
3494
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3495
d2,
3496
_bz_VecExprConstant<complex<T3> > (d3)));
3497
}
3498
#endif // BZ_HAVE_COMPLEX
3499
3500
// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, Vector<P_numtype3>)
3501
template<class P_numtype1, class P_numtype2, class P_numtype3>
3502
inline
3503
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3504
VectorPickIterConst<P_numtype2>,
3505
VectorIterConst<P_numtype3> > >
3506
where(const VectorPick<P_numtype1>& d1,
3507
const VectorPick<P_numtype2>& d2,
3508
const Vector<P_numtype3>& d3)
3509
{
3510
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3511
VectorPickIterConst<P_numtype2>,
3512
VectorIterConst<P_numtype3> > T_expr;
3513
3514
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3515
d2.beginFast(),
3516
d3.beginFast()));
3517
}
3518
3519
// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, _bz_VecExpr<P_expr3>)
3520
template<class P_numtype1, class P_numtype2, class P_expr3>
3521
inline
3522
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3523
VectorPickIterConst<P_numtype2>,
3524
_bz_VecExpr<P_expr3> > >
3525
where(const VectorPick<P_numtype1>& d1,
3526
const VectorPick<P_numtype2>& d2,
3527
_bz_VecExpr<P_expr3> d3)
3528
{
3529
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3530
VectorPickIterConst<P_numtype2>,
3531
_bz_VecExpr<P_expr3> > T_expr;
3532
3533
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3534
d2.beginFast(),
3535
d3));
3536
}
3537
3538
// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, VectorPick<P_numtype3>)
3539
template<class P_numtype1, class P_numtype2, class P_numtype3>
3540
inline
3541
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3542
VectorPickIterConst<P_numtype2>,
3543
VectorPickIterConst<P_numtype3> > >
3544
where(const VectorPick<P_numtype1>& d1,
3545
const VectorPick<P_numtype2>& d2,
3546
const VectorPick<P_numtype3>& d3)
3547
{
3548
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3549
VectorPickIterConst<P_numtype2>,
3550
VectorPickIterConst<P_numtype3> > T_expr;
3551
3552
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3553
d2.beginFast(),
3554
d3.beginFast()));
3555
}
3556
3557
// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, Range)
3558
template<class P_numtype1, class P_numtype2>
3559
inline
3560
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3561
VectorPickIterConst<P_numtype2>,
3562
Range > >
3563
where(const VectorPick<P_numtype1>& d1,
3564
const VectorPick<P_numtype2>& d2,
3565
Range d3)
3566
{
3567
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3568
VectorPickIterConst<P_numtype2>,
3569
Range > T_expr;
3570
3571
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3572
d2.beginFast(),
3573
d3));
3574
}
3575
3576
// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, TinyVector<P_numtype3, N_length3>)
3577
template<class P_numtype1, class P_numtype2, class P_numtype3, int N_length3>
3578
inline
3579
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3580
VectorPickIterConst<P_numtype2>,
3581
TinyVectorIterConst<P_numtype3, N_length3> > >
3582
where(const VectorPick<P_numtype1>& d1,
3583
const VectorPick<P_numtype2>& d2,
3584
const TinyVector<P_numtype3, N_length3>& d3)
3585
{
3586
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3587
VectorPickIterConst<P_numtype2>,
3588
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
3589
3590
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3591
d2.beginFast(),
3592
d3.beginFast()));
3593
}
3594
3595
// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, int)
3596
template<class P_numtype1, class P_numtype2>
3597
inline
3598
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3599
VectorPickIterConst<P_numtype2>,
3600
_bz_VecExprConstant<int> > >
3601
where(const VectorPick<P_numtype1>& d1,
3602
const VectorPick<P_numtype2>& d2,
3603
int d3)
3604
{
3605
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3606
VectorPickIterConst<P_numtype2>,
3607
_bz_VecExprConstant<int> > T_expr;
3608
3609
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3610
d2.beginFast(),
3611
_bz_VecExprConstant<int>(d3)));
3612
}
3613
3614
// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, float)
3615
template<class P_numtype1, class P_numtype2>
3616
inline
3617
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3618
VectorPickIterConst<P_numtype2>,
3619
_bz_VecExprConstant<float> > >
3620
where(const VectorPick<P_numtype1>& d1,
3621
const VectorPick<P_numtype2>& d2,
3622
float d3)
3623
{
3624
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3625
VectorPickIterConst<P_numtype2>,
3626
_bz_VecExprConstant<float> > T_expr;
3627
3628
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3629
d2.beginFast(),
3630
_bz_VecExprConstant<float>(d3)));
3631
}
3632
3633
// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, double)
3634
template<class P_numtype1, class P_numtype2>
3635
inline
3636
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3637
VectorPickIterConst<P_numtype2>,
3638
_bz_VecExprConstant<double> > >
3639
where(const VectorPick<P_numtype1>& d1,
3640
const VectorPick<P_numtype2>& d2,
3641
double d3)
3642
{
3643
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3644
VectorPickIterConst<P_numtype2>,
3645
_bz_VecExprConstant<double> > T_expr;
3646
3647
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3648
d2.beginFast(),
3649
_bz_VecExprConstant<double>(d3)));
3650
}
3651
3652
// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, long double)
3653
template<class P_numtype1, class P_numtype2>
3654
inline
3655
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3656
VectorPickIterConst<P_numtype2>,
3657
_bz_VecExprConstant<long double> > >
3658
where(const VectorPick<P_numtype1>& d1,
3659
const VectorPick<P_numtype2>& d2,
3660
long double d3)
3661
{
3662
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3663
VectorPickIterConst<P_numtype2>,
3664
_bz_VecExprConstant<long double> > T_expr;
3665
3666
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3667
d2.beginFast(),
3668
_bz_VecExprConstant<long double>(d3)));
3669
}
3670
3671
// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, complex<T3>)
3672
#ifdef BZ_HAVE_COMPLEX
3673
template<class P_numtype1, class P_numtype2, class T3>
3674
inline
3675
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3676
VectorPickIterConst<P_numtype2>,
3677
_bz_VecExprConstant<complex<T3> > > >
3678
where(const VectorPick<P_numtype1>& d1,
3679
const VectorPick<P_numtype2>& d2,
3680
complex<T3> d3)
3681
{
3682
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3683
VectorPickIterConst<P_numtype2>,
3684
_bz_VecExprConstant<complex<T3> > > T_expr;
3685
3686
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3687
d2.beginFast(),
3688
_bz_VecExprConstant<complex<T3> > (d3)));
3689
}
3690
#endif // BZ_HAVE_COMPLEX
3691
3692
// where(VectorPick<P_numtype1>, Range, Vector<P_numtype3>)
3693
template<class P_numtype1, class P_numtype3>
3694
inline
3695
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3696
Range,
3697
VectorIterConst<P_numtype3> > >
3698
where(const VectorPick<P_numtype1>& d1,
3699
Range d2,
3700
const Vector<P_numtype3>& d3)
3701
{
3702
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3703
Range,
3704
VectorIterConst<P_numtype3> > T_expr;
3705
3706
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3707
d2,
3708
d3.beginFast()));
3709
}
3710
3711
// where(VectorPick<P_numtype1>, Range, _bz_VecExpr<P_expr3>)
3712
template<class P_numtype1, class P_expr3>
3713
inline
3714
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3715
Range,
3716
_bz_VecExpr<P_expr3> > >
3717
where(const VectorPick<P_numtype1>& d1,
3718
Range d2,
3719
_bz_VecExpr<P_expr3> d3)
3720
{
3721
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3722
Range,
3723
_bz_VecExpr<P_expr3> > T_expr;
3724
3725
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3726
d2,
3727
d3));
3728
}
3729
3730
// where(VectorPick<P_numtype1>, Range, VectorPick<P_numtype3>)
3731
template<class P_numtype1, class P_numtype3>
3732
inline
3733
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3734
Range,
3735
VectorPickIterConst<P_numtype3> > >
3736
where(const VectorPick<P_numtype1>& d1,
3737
Range d2,
3738
const VectorPick<P_numtype3>& d3)
3739
{
3740
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3741
Range,
3742
VectorPickIterConst<P_numtype3> > T_expr;
3743
3744
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3745
d2,
3746
d3.beginFast()));
3747
}
3748
3749
// where(VectorPick<P_numtype1>, Range, Range)
3750
template<class P_numtype1>
3751
inline
3752
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3753
Range,
3754
Range > >
3755
where(const VectorPick<P_numtype1>& d1,
3756
Range d2,
3757
Range d3)
3758
{
3759
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3760
Range,
3761
Range > T_expr;
3762
3763
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3764
d2,
3765
d3));
3766
}
3767
3768
// where(VectorPick<P_numtype1>, Range, TinyVector<P_numtype3, N_length3>)
3769
template<class P_numtype1, class P_numtype3, int N_length3>
3770
inline
3771
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3772
Range,
3773
TinyVectorIterConst<P_numtype3, N_length3> > >
3774
where(const VectorPick<P_numtype1>& d1,
3775
Range d2,
3776
const TinyVector<P_numtype3, N_length3>& d3)
3777
{
3778
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3779
Range,
3780
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
3781
3782
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3783
d2,
3784
d3.beginFast()));
3785
}
3786
3787
// where(VectorPick<P_numtype1>, Range, int)
3788
template<class P_numtype1>
3789
inline
3790
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3791
Range,
3792
_bz_VecExprConstant<int> > >
3793
where(const VectorPick<P_numtype1>& d1,
3794
Range d2,
3795
int d3)
3796
{
3797
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3798
Range,
3799
_bz_VecExprConstant<int> > T_expr;
3800
3801
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3802
d2,
3803
_bz_VecExprConstant<int>(d3)));
3804
}
3805
3806
// where(VectorPick<P_numtype1>, Range, float)
3807
template<class P_numtype1>
3808
inline
3809
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3810
Range,
3811
_bz_VecExprConstant<float> > >
3812
where(const VectorPick<P_numtype1>& d1,
3813
Range d2,
3814
float d3)
3815
{
3816
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3817
Range,
3818
_bz_VecExprConstant<float> > T_expr;
3819
3820
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3821
d2,
3822
_bz_VecExprConstant<float>(d3)));
3823
}
3824
3825
// where(VectorPick<P_numtype1>, Range, double)
3826
template<class P_numtype1>
3827
inline
3828
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3829
Range,
3830
_bz_VecExprConstant<double> > >
3831
where(const VectorPick<P_numtype1>& d1,
3832
Range d2,
3833
double d3)
3834
{
3835
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3836
Range,
3837
_bz_VecExprConstant<double> > T_expr;
3838
3839
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3840
d2,
3841
_bz_VecExprConstant<double>(d3)));
3842
}
3843
3844
// where(VectorPick<P_numtype1>, Range, long double)
3845
template<class P_numtype1>
3846
inline
3847
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3848
Range,
3849
_bz_VecExprConstant<long double> > >
3850
where(const VectorPick<P_numtype1>& d1,
3851
Range d2,
3852
long double d3)
3853
{
3854
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3855
Range,
3856
_bz_VecExprConstant<long double> > T_expr;
3857
3858
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3859
d2,
3860
_bz_VecExprConstant<long double>(d3)));
3861
}
3862
3863
// where(VectorPick<P_numtype1>, Range, complex<T3>)
3864
#ifdef BZ_HAVE_COMPLEX
3865
template<class P_numtype1, class T3>
3866
inline
3867
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3868
Range,
3869
_bz_VecExprConstant<complex<T3> > > >
3870
where(const VectorPick<P_numtype1>& d1,
3871
Range d2,
3872
complex<T3> d3)
3873
{
3874
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3875
Range,
3876
_bz_VecExprConstant<complex<T3> > > T_expr;
3877
3878
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3879
d2,
3880
_bz_VecExprConstant<complex<T3> > (d3)));
3881
}
3882
#endif // BZ_HAVE_COMPLEX
3883
3884
// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, Vector<P_numtype3>)
3885
template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3>
3886
inline
3887
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3888
TinyVectorIterConst<P_numtype2, N_length2>,
3889
VectorIterConst<P_numtype3> > >
3890
where(const VectorPick<P_numtype1>& d1,
3891
const TinyVector<P_numtype2, N_length2>& d2,
3892
const Vector<P_numtype3>& d3)
3893
{
3894
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3895
TinyVectorIterConst<P_numtype2, N_length2>,
3896
VectorIterConst<P_numtype3> > T_expr;
3897
3898
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3899
d2.beginFast(),
3900
d3.beginFast()));
3901
}
3902
3903
// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, _bz_VecExpr<P_expr3>)
3904
template<class P_numtype1, class P_numtype2, int N_length2, class P_expr3>
3905
inline
3906
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3907
TinyVectorIterConst<P_numtype2, N_length2>,
3908
_bz_VecExpr<P_expr3> > >
3909
where(const VectorPick<P_numtype1>& d1,
3910
const TinyVector<P_numtype2, N_length2>& d2,
3911
_bz_VecExpr<P_expr3> d3)
3912
{
3913
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3914
TinyVectorIterConst<P_numtype2, N_length2>,
3915
_bz_VecExpr<P_expr3> > T_expr;
3916
3917
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3918
d2.beginFast(),
3919
d3));
3920
}
3921
3922
// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, VectorPick<P_numtype3>)
3923
template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3>
3924
inline
3925
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3926
TinyVectorIterConst<P_numtype2, N_length2>,
3927
VectorPickIterConst<P_numtype3> > >
3928
where(const VectorPick<P_numtype1>& d1,
3929
const TinyVector<P_numtype2, N_length2>& d2,
3930
const VectorPick<P_numtype3>& d3)
3931
{
3932
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3933
TinyVectorIterConst<P_numtype2, N_length2>,
3934
VectorPickIterConst<P_numtype3> > T_expr;
3935
3936
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3937
d2.beginFast(),
3938
d3.beginFast()));
3939
}
3940
3941
// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, Range)
3942
template<class P_numtype1, class P_numtype2, int N_length2>
3943
inline
3944
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3945
TinyVectorIterConst<P_numtype2, N_length2>,
3946
Range > >
3947
where(const VectorPick<P_numtype1>& d1,
3948
const TinyVector<P_numtype2, N_length2>& d2,
3949
Range d3)
3950
{
3951
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3952
TinyVectorIterConst<P_numtype2, N_length2>,
3953
Range > T_expr;
3954
3955
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3956
d2.beginFast(),
3957
d3));
3958
}
3959
3960
// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, TinyVector<P_numtype3, N_length3>)
3961
template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3, int N_length3>
3962
inline
3963
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3964
TinyVectorIterConst<P_numtype2, N_length2>,
3965
TinyVectorIterConst<P_numtype3, N_length3> > >
3966
where(const VectorPick<P_numtype1>& d1,
3967
const TinyVector<P_numtype2, N_length2>& d2,
3968
const TinyVector<P_numtype3, N_length3>& d3)
3969
{
3970
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3971
TinyVectorIterConst<P_numtype2, N_length2>,
3972
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
3973
3974
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3975
d2.beginFast(),
3976
d3.beginFast()));
3977
}
3978
3979
// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, int)
3980
template<class P_numtype1, class P_numtype2, int N_length2>
3981
inline
3982
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
3983
TinyVectorIterConst<P_numtype2, N_length2>,
3984
_bz_VecExprConstant<int> > >
3985
where(const VectorPick<P_numtype1>& d1,
3986
const TinyVector<P_numtype2, N_length2>& d2,
3987
int d3)
3988
{
3989
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
3990
TinyVectorIterConst<P_numtype2, N_length2>,
3991
_bz_VecExprConstant<int> > T_expr;
3992
3993
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
3994
d2.beginFast(),
3995
_bz_VecExprConstant<int>(d3)));
3996
}
3997
3998
// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, float)
3999
template<class P_numtype1, class P_numtype2, int N_length2>
4000
inline
4001
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4002
TinyVectorIterConst<P_numtype2, N_length2>,
4003
_bz_VecExprConstant<float> > >
4004
where(const VectorPick<P_numtype1>& d1,
4005
const TinyVector<P_numtype2, N_length2>& d2,
4006
float d3)
4007
{
4008
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4009
TinyVectorIterConst<P_numtype2, N_length2>,
4010
_bz_VecExprConstant<float> > T_expr;
4011
4012
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4013
d2.beginFast(),
4014
_bz_VecExprConstant<float>(d3)));
4015
}
4016
4017
// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, double)
4018
template<class P_numtype1, class P_numtype2, int N_length2>
4019
inline
4020
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4021
TinyVectorIterConst<P_numtype2, N_length2>,
4022
_bz_VecExprConstant<double> > >
4023
where(const VectorPick<P_numtype1>& d1,
4024
const TinyVector<P_numtype2, N_length2>& d2,
4025
double d3)
4026
{
4027
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4028
TinyVectorIterConst<P_numtype2, N_length2>,
4029
_bz_VecExprConstant<double> > T_expr;
4030
4031
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4032
d2.beginFast(),
4033
_bz_VecExprConstant<double>(d3)));
4034
}
4035
4036
// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, long double)
4037
template<class P_numtype1, class P_numtype2, int N_length2>
4038
inline
4039
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4040
TinyVectorIterConst<P_numtype2, N_length2>,
4041
_bz_VecExprConstant<long double> > >
4042
where(const VectorPick<P_numtype1>& d1,
4043
const TinyVector<P_numtype2, N_length2>& d2,
4044
long double d3)
4045
{
4046
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4047
TinyVectorIterConst<P_numtype2, N_length2>,
4048
_bz_VecExprConstant<long double> > T_expr;
4049
4050
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4051
d2.beginFast(),
4052
_bz_VecExprConstant<long double>(d3)));
4053
}
4054
4055
// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, complex<T3>)
4056
#ifdef BZ_HAVE_COMPLEX
4057
template<class P_numtype1, class P_numtype2, int N_length2, class T3>
4058
inline
4059
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4060
TinyVectorIterConst<P_numtype2, N_length2>,
4061
_bz_VecExprConstant<complex<T3> > > >
4062
where(const VectorPick<P_numtype1>& d1,
4063
const TinyVector<P_numtype2, N_length2>& d2,
4064
complex<T3> d3)
4065
{
4066
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4067
TinyVectorIterConst<P_numtype2, N_length2>,
4068
_bz_VecExprConstant<complex<T3> > > T_expr;
4069
4070
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4071
d2.beginFast(),
4072
_bz_VecExprConstant<complex<T3> > (d3)));
4073
}
4074
#endif // BZ_HAVE_COMPLEX
4075
4076
// where(VectorPick<P_numtype1>, int, Vector<P_numtype3>)
4077
template<class P_numtype1, class P_numtype3>
4078
inline
4079
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4080
_bz_VecExprConstant<int>,
4081
VectorIterConst<P_numtype3> > >
4082
where(const VectorPick<P_numtype1>& d1,
4083
int d2,
4084
const Vector<P_numtype3>& d3)
4085
{
4086
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4087
_bz_VecExprConstant<int>,
4088
VectorIterConst<P_numtype3> > T_expr;
4089
4090
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4091
_bz_VecExprConstant<int>(d2),
4092
d3.beginFast()));
4093
}
4094
4095
// where(VectorPick<P_numtype1>, int, _bz_VecExpr<P_expr3>)
4096
template<class P_numtype1, class P_expr3>
4097
inline
4098
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4099
_bz_VecExprConstant<int>,
4100
_bz_VecExpr<P_expr3> > >
4101
where(const VectorPick<P_numtype1>& d1,
4102
int d2,
4103
_bz_VecExpr<P_expr3> d3)
4104
{
4105
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4106
_bz_VecExprConstant<int>,
4107
_bz_VecExpr<P_expr3> > T_expr;
4108
4109
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4110
_bz_VecExprConstant<int>(d2),
4111
d3));
4112
}
4113
4114
// where(VectorPick<P_numtype1>, int, VectorPick<P_numtype3>)
4115
template<class P_numtype1, class P_numtype3>
4116
inline
4117
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4118
_bz_VecExprConstant<int>,
4119
VectorPickIterConst<P_numtype3> > >
4120
where(const VectorPick<P_numtype1>& d1,
4121
int d2,
4122
const VectorPick<P_numtype3>& d3)
4123
{
4124
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4125
_bz_VecExprConstant<int>,
4126
VectorPickIterConst<P_numtype3> > T_expr;
4127
4128
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4129
_bz_VecExprConstant<int>(d2),
4130
d3.beginFast()));
4131
}
4132
4133
// where(VectorPick<P_numtype1>, int, Range)
4134
template<class P_numtype1>
4135
inline
4136
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4137
_bz_VecExprConstant<int>,
4138
Range > >
4139
where(const VectorPick<P_numtype1>& d1,
4140
int d2,
4141
Range d3)
4142
{
4143
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4144
_bz_VecExprConstant<int>,
4145
Range > T_expr;
4146
4147
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4148
_bz_VecExprConstant<int>(d2),
4149
d3));
4150
}
4151
4152
// where(VectorPick<P_numtype1>, int, TinyVector<P_numtype3, N_length3>)
4153
template<class P_numtype1, class P_numtype3, int N_length3>
4154
inline
4155
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4156
_bz_VecExprConstant<int>,
4157
TinyVectorIterConst<P_numtype3, N_length3> > >
4158
where(const VectorPick<P_numtype1>& d1,
4159
int d2,
4160
const TinyVector<P_numtype3, N_length3>& d3)
4161
{
4162
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4163
_bz_VecExprConstant<int>,
4164
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
4165
4166
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4167
_bz_VecExprConstant<int>(d2),
4168
d3.beginFast()));
4169
}
4170
4171
// where(VectorPick<P_numtype1>, int, int)
4172
template<class P_numtype1>
4173
inline
4174
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4175
_bz_VecExprConstant<int>,
4176
_bz_VecExprConstant<int> > >
4177
where(const VectorPick<P_numtype1>& d1,
4178
int d2,
4179
int d3)
4180
{
4181
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4182
_bz_VecExprConstant<int>,
4183
_bz_VecExprConstant<int> > T_expr;
4184
4185
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4186
_bz_VecExprConstant<int>(d2),
4187
_bz_VecExprConstant<int>(d3)));
4188
}
4189
4190
// where(VectorPick<P_numtype1>, float, Vector<P_numtype3>)
4191
template<class P_numtype1, class P_numtype3>
4192
inline
4193
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4194
_bz_VecExprConstant<float>,
4195
VectorIterConst<P_numtype3> > >
4196
where(const VectorPick<P_numtype1>& d1,
4197
float d2,
4198
const Vector<P_numtype3>& d3)
4199
{
4200
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4201
_bz_VecExprConstant<float>,
4202
VectorIterConst<P_numtype3> > T_expr;
4203
4204
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4205
_bz_VecExprConstant<float>(d2),
4206
d3.beginFast()));
4207
}
4208
4209
// where(VectorPick<P_numtype1>, float, _bz_VecExpr<P_expr3>)
4210
template<class P_numtype1, class P_expr3>
4211
inline
4212
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4213
_bz_VecExprConstant<float>,
4214
_bz_VecExpr<P_expr3> > >
4215
where(const VectorPick<P_numtype1>& d1,
4216
float d2,
4217
_bz_VecExpr<P_expr3> d3)
4218
{
4219
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4220
_bz_VecExprConstant<float>,
4221
_bz_VecExpr<P_expr3> > T_expr;
4222
4223
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4224
_bz_VecExprConstant<float>(d2),
4225
d3));
4226
}
4227
4228
// where(VectorPick<P_numtype1>, float, VectorPick<P_numtype3>)
4229
template<class P_numtype1, class P_numtype3>
4230
inline
4231
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4232
_bz_VecExprConstant<float>,
4233
VectorPickIterConst<P_numtype3> > >
4234
where(const VectorPick<P_numtype1>& d1,
4235
float d2,
4236
const VectorPick<P_numtype3>& d3)
4237
{
4238
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4239
_bz_VecExprConstant<float>,
4240
VectorPickIterConst<P_numtype3> > T_expr;
4241
4242
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4243
_bz_VecExprConstant<float>(d2),
4244
d3.beginFast()));
4245
}
4246
4247
// where(VectorPick<P_numtype1>, float, Range)
4248
template<class P_numtype1>
4249
inline
4250
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4251
_bz_VecExprConstant<float>,
4252
Range > >
4253
where(const VectorPick<P_numtype1>& d1,
4254
float d2,
4255
Range d3)
4256
{
4257
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4258
_bz_VecExprConstant<float>,
4259
Range > T_expr;
4260
4261
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4262
_bz_VecExprConstant<float>(d2),
4263
d3));
4264
}
4265
4266
// where(VectorPick<P_numtype1>, float, TinyVector<P_numtype3, N_length3>)
4267
template<class P_numtype1, class P_numtype3, int N_length3>
4268
inline
4269
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4270
_bz_VecExprConstant<float>,
4271
TinyVectorIterConst<P_numtype3, N_length3> > >
4272
where(const VectorPick<P_numtype1>& d1,
4273
float d2,
4274
const TinyVector<P_numtype3, N_length3>& d3)
4275
{
4276
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4277
_bz_VecExprConstant<float>,
4278
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
4279
4280
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4281
_bz_VecExprConstant<float>(d2),
4282
d3.beginFast()));
4283
}
4284
4285
// where(VectorPick<P_numtype1>, float, float)
4286
template<class P_numtype1>
4287
inline
4288
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4289
_bz_VecExprConstant<float>,
4290
_bz_VecExprConstant<float> > >
4291
where(const VectorPick<P_numtype1>& d1,
4292
float d2,
4293
float d3)
4294
{
4295
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4296
_bz_VecExprConstant<float>,
4297
_bz_VecExprConstant<float> > T_expr;
4298
4299
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4300
_bz_VecExprConstant<float>(d2),
4301
_bz_VecExprConstant<float>(d3)));
4302
}
4303
4304
// where(VectorPick<P_numtype1>, double, Vector<P_numtype3>)
4305
template<class P_numtype1, class P_numtype3>
4306
inline
4307
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4308
_bz_VecExprConstant<double>,
4309
VectorIterConst<P_numtype3> > >
4310
where(const VectorPick<P_numtype1>& d1,
4311
double d2,
4312
const Vector<P_numtype3>& d3)
4313
{
4314
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4315
_bz_VecExprConstant<double>,
4316
VectorIterConst<P_numtype3> > T_expr;
4317
4318
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4319
_bz_VecExprConstant<double>(d2),
4320
d3.beginFast()));
4321
}
4322
4323
// where(VectorPick<P_numtype1>, double, _bz_VecExpr<P_expr3>)
4324
template<class P_numtype1, class P_expr3>
4325
inline
4326
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4327
_bz_VecExprConstant<double>,
4328
_bz_VecExpr<P_expr3> > >
4329
where(const VectorPick<P_numtype1>& d1,
4330
double d2,
4331
_bz_VecExpr<P_expr3> d3)
4332
{
4333
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4334
_bz_VecExprConstant<double>,
4335
_bz_VecExpr<P_expr3> > T_expr;
4336
4337
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4338
_bz_VecExprConstant<double>(d2),
4339
d3));
4340
}
4341
4342
// where(VectorPick<P_numtype1>, double, VectorPick<P_numtype3>)
4343
template<class P_numtype1, class P_numtype3>
4344
inline
4345
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4346
_bz_VecExprConstant<double>,
4347
VectorPickIterConst<P_numtype3> > >
4348
where(const VectorPick<P_numtype1>& d1,
4349
double d2,
4350
const VectorPick<P_numtype3>& d3)
4351
{
4352
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4353
_bz_VecExprConstant<double>,
4354
VectorPickIterConst<P_numtype3> > T_expr;
4355
4356
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4357
_bz_VecExprConstant<double>(d2),
4358
d3.beginFast()));
4359
}
4360
4361
// where(VectorPick<P_numtype1>, double, Range)
4362
template<class P_numtype1>
4363
inline
4364
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4365
_bz_VecExprConstant<double>,
4366
Range > >
4367
where(const VectorPick<P_numtype1>& d1,
4368
double d2,
4369
Range d3)
4370
{
4371
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4372
_bz_VecExprConstant<double>,
4373
Range > T_expr;
4374
4375
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4376
_bz_VecExprConstant<double>(d2),
4377
d3));
4378
}
4379
4380
// where(VectorPick<P_numtype1>, double, TinyVector<P_numtype3, N_length3>)
4381
template<class P_numtype1, class P_numtype3, int N_length3>
4382
inline
4383
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4384
_bz_VecExprConstant<double>,
4385
TinyVectorIterConst<P_numtype3, N_length3> > >
4386
where(const VectorPick<P_numtype1>& d1,
4387
double d2,
4388
const TinyVector<P_numtype3, N_length3>& d3)
4389
{
4390
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4391
_bz_VecExprConstant<double>,
4392
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
4393
4394
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4395
_bz_VecExprConstant<double>(d2),
4396
d3.beginFast()));
4397
}
4398
4399
// where(VectorPick<P_numtype1>, double, double)
4400
template<class P_numtype1>
4401
inline
4402
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4403
_bz_VecExprConstant<double>,
4404
_bz_VecExprConstant<double> > >
4405
where(const VectorPick<P_numtype1>& d1,
4406
double d2,
4407
double d3)
4408
{
4409
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4410
_bz_VecExprConstant<double>,
4411
_bz_VecExprConstant<double> > T_expr;
4412
4413
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4414
_bz_VecExprConstant<double>(d2),
4415
_bz_VecExprConstant<double>(d3)));
4416
}
4417
4418
// where(VectorPick<P_numtype1>, long double, Vector<P_numtype3>)
4419
template<class P_numtype1, class P_numtype3>
4420
inline
4421
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4422
_bz_VecExprConstant<long double>,
4423
VectorIterConst<P_numtype3> > >
4424
where(const VectorPick<P_numtype1>& d1,
4425
long double d2,
4426
const Vector<P_numtype3>& d3)
4427
{
4428
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4429
_bz_VecExprConstant<long double>,
4430
VectorIterConst<P_numtype3> > T_expr;
4431
4432
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4433
_bz_VecExprConstant<long double>(d2),
4434
d3.beginFast()));
4435
}
4436
4437
// where(VectorPick<P_numtype1>, long double, _bz_VecExpr<P_expr3>)
4438
template<class P_numtype1, class P_expr3>
4439
inline
4440
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4441
_bz_VecExprConstant<long double>,
4442
_bz_VecExpr<P_expr3> > >
4443
where(const VectorPick<P_numtype1>& d1,
4444
long double d2,
4445
_bz_VecExpr<P_expr3> d3)
4446
{
4447
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4448
_bz_VecExprConstant<long double>,
4449
_bz_VecExpr<P_expr3> > T_expr;
4450
4451
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4452
_bz_VecExprConstant<long double>(d2),
4453
d3));
4454
}
4455
4456
// where(VectorPick<P_numtype1>, long double, VectorPick<P_numtype3>)
4457
template<class P_numtype1, class P_numtype3>
4458
inline
4459
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4460
_bz_VecExprConstant<long double>,
4461
VectorPickIterConst<P_numtype3> > >
4462
where(const VectorPick<P_numtype1>& d1,
4463
long double d2,
4464
const VectorPick<P_numtype3>& d3)
4465
{
4466
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4467
_bz_VecExprConstant<long double>,
4468
VectorPickIterConst<P_numtype3> > T_expr;
4469
4470
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4471
_bz_VecExprConstant<long double>(d2),
4472
d3.beginFast()));
4473
}
4474
4475
// where(VectorPick<P_numtype1>, long double, Range)
4476
template<class P_numtype1>
4477
inline
4478
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4479
_bz_VecExprConstant<long double>,
4480
Range > >
4481
where(const VectorPick<P_numtype1>& d1,
4482
long double d2,
4483
Range d3)
4484
{
4485
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4486
_bz_VecExprConstant<long double>,
4487
Range > T_expr;
4488
4489
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4490
_bz_VecExprConstant<long double>(d2),
4491
d3));
4492
}
4493
4494
// where(VectorPick<P_numtype1>, long double, TinyVector<P_numtype3, N_length3>)
4495
template<class P_numtype1, class P_numtype3, int N_length3>
4496
inline
4497
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4498
_bz_VecExprConstant<long double>,
4499
TinyVectorIterConst<P_numtype3, N_length3> > >
4500
where(const VectorPick<P_numtype1>& d1,
4501
long double d2,
4502
const TinyVector<P_numtype3, N_length3>& d3)
4503
{
4504
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4505
_bz_VecExprConstant<long double>,
4506
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
4507
4508
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4509
_bz_VecExprConstant<long double>(d2),
4510
d3.beginFast()));
4511
}
4512
4513
// where(VectorPick<P_numtype1>, long double, long double)
4514
template<class P_numtype1>
4515
inline
4516
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4517
_bz_VecExprConstant<long double>,
4518
_bz_VecExprConstant<long double> > >
4519
where(const VectorPick<P_numtype1>& d1,
4520
long double d2,
4521
long double d3)
4522
{
4523
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4524
_bz_VecExprConstant<long double>,
4525
_bz_VecExprConstant<long double> > T_expr;
4526
4527
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4528
_bz_VecExprConstant<long double>(d2),
4529
_bz_VecExprConstant<long double>(d3)));
4530
}
4531
4532
// where(VectorPick<P_numtype1>, complex<T2>, Vector<P_numtype3>)
4533
#ifdef BZ_HAVE_COMPLEX
4534
template<class P_numtype1, class T2, class P_numtype3>
4535
inline
4536
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4537
_bz_VecExprConstant<complex<T2> > ,
4538
VectorIterConst<P_numtype3> > >
4539
where(const VectorPick<P_numtype1>& d1,
4540
complex<T2> d2,
4541
const Vector<P_numtype3>& d3)
4542
{
4543
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4544
_bz_VecExprConstant<complex<T2> > ,
4545
VectorIterConst<P_numtype3> > T_expr;
4546
4547
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4548
_bz_VecExprConstant<complex<T2> > (d2),
4549
d3.beginFast()));
4550
}
4551
#endif // BZ_HAVE_COMPLEX
4552
4553
// where(VectorPick<P_numtype1>, complex<T2>, _bz_VecExpr<P_expr3>)
4554
#ifdef BZ_HAVE_COMPLEX
4555
template<class P_numtype1, class T2, class P_expr3>
4556
inline
4557
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4558
_bz_VecExprConstant<complex<T2> > ,
4559
_bz_VecExpr<P_expr3> > >
4560
where(const VectorPick<P_numtype1>& d1,
4561
complex<T2> d2,
4562
_bz_VecExpr<P_expr3> d3)
4563
{
4564
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4565
_bz_VecExprConstant<complex<T2> > ,
4566
_bz_VecExpr<P_expr3> > T_expr;
4567
4568
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4569
_bz_VecExprConstant<complex<T2> > (d2),
4570
d3));
4571
}
4572
#endif // BZ_HAVE_COMPLEX
4573
4574
// where(VectorPick<P_numtype1>, complex<T2>, VectorPick<P_numtype3>)
4575
#ifdef BZ_HAVE_COMPLEX
4576
template<class P_numtype1, class T2, class P_numtype3>
4577
inline
4578
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4579
_bz_VecExprConstant<complex<T2> > ,
4580
VectorPickIterConst<P_numtype3> > >
4581
where(const VectorPick<P_numtype1>& d1,
4582
complex<T2> d2,
4583
const VectorPick<P_numtype3>& d3)
4584
{
4585
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4586
_bz_VecExprConstant<complex<T2> > ,
4587
VectorPickIterConst<P_numtype3> > T_expr;
4588
4589
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4590
_bz_VecExprConstant<complex<T2> > (d2),
4591
d3.beginFast()));
4592
}
4593
#endif // BZ_HAVE_COMPLEX
4594
4595
// where(VectorPick<P_numtype1>, complex<T2>, Range)
4596
#ifdef BZ_HAVE_COMPLEX
4597
template<class P_numtype1, class T2>
4598
inline
4599
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4600
_bz_VecExprConstant<complex<T2> > ,
4601
Range > >
4602
where(const VectorPick<P_numtype1>& d1,
4603
complex<T2> d2,
4604
Range d3)
4605
{
4606
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4607
_bz_VecExprConstant<complex<T2> > ,
4608
Range > T_expr;
4609
4610
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4611
_bz_VecExprConstant<complex<T2> > (d2),
4612
d3));
4613
}
4614
#endif // BZ_HAVE_COMPLEX
4615
4616
// where(VectorPick<P_numtype1>, complex<T2>, TinyVector<P_numtype3, N_length3>)
4617
#ifdef BZ_HAVE_COMPLEX
4618
template<class P_numtype1, class T2, class P_numtype3, int N_length3>
4619
inline
4620
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4621
_bz_VecExprConstant<complex<T2> > ,
4622
TinyVectorIterConst<P_numtype3, N_length3> > >
4623
where(const VectorPick<P_numtype1>& d1,
4624
complex<T2> d2,
4625
const TinyVector<P_numtype3, N_length3>& d3)
4626
{
4627
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4628
_bz_VecExprConstant<complex<T2> > ,
4629
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
4630
4631
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4632
_bz_VecExprConstant<complex<T2> > (d2),
4633
d3.beginFast()));
4634
}
4635
#endif // BZ_HAVE_COMPLEX
4636
4637
// where(VectorPick<P_numtype1>, complex<T2>, complex<T3>)
4638
#ifdef BZ_HAVE_COMPLEX
4639
template<class P_numtype1, class T2, class T3>
4640
inline
4641
_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>,
4642
_bz_VecExprConstant<complex<T2> > ,
4643
_bz_VecExprConstant<complex<T3> > > >
4644
where(const VectorPick<P_numtype1>& d1,
4645
complex<T2> d2,
4646
complex<T3> d3)
4647
{
4648
typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>,
4649
_bz_VecExprConstant<complex<T2> > ,
4650
_bz_VecExprConstant<complex<T3> > > T_expr;
4651
4652
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
4653
_bz_VecExprConstant<complex<T2> > (d2),
4654
_bz_VecExprConstant<complex<T3> > (d3)));
4655
}
4656
#endif // BZ_HAVE_COMPLEX
4657
4658
// where(Range, Vector<P_numtype2>, Vector<P_numtype3>)
4659
template<class P_numtype2, class P_numtype3>
4660
inline
4661
_bz_VecExpr<_bz_VecWhere<Range,
4662
VectorIterConst<P_numtype2>,
4663
VectorIterConst<P_numtype3> > >
4664
where(Range d1,
4665
const Vector<P_numtype2>& d2,
4666
const Vector<P_numtype3>& d3)
4667
{
4668
typedef _bz_VecWhere<Range,
4669
VectorIterConst<P_numtype2>,
4670
VectorIterConst<P_numtype3> > T_expr;
4671
4672
return _bz_VecExpr<T_expr>(T_expr(d1,
4673
d2.beginFast(),
4674
d3.beginFast()));
4675
}
4676
4677
// where(Range, Vector<P_numtype2>, _bz_VecExpr<P_expr3>)
4678
template<class P_numtype2, class P_expr3>
4679
inline
4680
_bz_VecExpr<_bz_VecWhere<Range,
4681
VectorIterConst<P_numtype2>,
4682
_bz_VecExpr<P_expr3> > >
4683
where(Range d1,
4684
const Vector<P_numtype2>& d2,
4685
_bz_VecExpr<P_expr3> d3)
4686
{
4687
typedef _bz_VecWhere<Range,
4688
VectorIterConst<P_numtype2>,
4689
_bz_VecExpr<P_expr3> > T_expr;
4690
4691
return _bz_VecExpr<T_expr>(T_expr(d1,
4692
d2.beginFast(),
4693
d3));
4694
}
4695
4696
// where(Range, Vector<P_numtype2>, VectorPick<P_numtype3>)
4697
template<class P_numtype2, class P_numtype3>
4698
inline
4699
_bz_VecExpr<_bz_VecWhere<Range,
4700
VectorIterConst<P_numtype2>,
4701
VectorPickIterConst<P_numtype3> > >
4702
where(Range d1,
4703
const Vector<P_numtype2>& d2,
4704
const VectorPick<P_numtype3>& d3)
4705
{
4706
typedef _bz_VecWhere<Range,
4707
VectorIterConst<P_numtype2>,
4708
VectorPickIterConst<P_numtype3> > T_expr;
4709
4710
return _bz_VecExpr<T_expr>(T_expr(d1,
4711
d2.beginFast(),
4712
d3.beginFast()));
4713
}
4714
4715
// where(Range, Vector<P_numtype2>, Range)
4716
template<class P_numtype2>
4717
inline
4718
_bz_VecExpr<_bz_VecWhere<Range,
4719
VectorIterConst<P_numtype2>,
4720
Range > >
4721
where(Range d1,
4722
const Vector<P_numtype2>& d2,
4723
Range d3)
4724
{
4725
typedef _bz_VecWhere<Range,
4726
VectorIterConst<P_numtype2>,
4727
Range > T_expr;
4728
4729
return _bz_VecExpr<T_expr>(T_expr(d1,
4730
d2.beginFast(),
4731
d3));
4732
}
4733
4734
// where(Range, Vector<P_numtype2>, TinyVector<P_numtype3, N_length3>)
4735
template<class P_numtype2, class P_numtype3, int N_length3>
4736
inline
4737
_bz_VecExpr<_bz_VecWhere<Range,
4738
VectorIterConst<P_numtype2>,
4739
TinyVectorIterConst<P_numtype3, N_length3> > >
4740
where(Range d1,
4741
const Vector<P_numtype2>& d2,
4742
const TinyVector<P_numtype3, N_length3>& d3)
4743
{
4744
typedef _bz_VecWhere<Range,
4745
VectorIterConst<P_numtype2>,
4746
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
4747
4748
return _bz_VecExpr<T_expr>(T_expr(d1,
4749
d2.beginFast(),
4750
d3.beginFast()));
4751
}
4752
4753
// where(Range, Vector<P_numtype2>, int)
4754
template<class P_numtype2>
4755
inline
4756
_bz_VecExpr<_bz_VecWhere<Range,
4757
VectorIterConst<P_numtype2>,
4758
_bz_VecExprConstant<int> > >
4759
where(Range d1,
4760
const Vector<P_numtype2>& d2,
4761
int d3)
4762
{
4763
typedef _bz_VecWhere<Range,
4764
VectorIterConst<P_numtype2>,
4765
_bz_VecExprConstant<int> > T_expr;
4766
4767
return _bz_VecExpr<T_expr>(T_expr(d1,
4768
d2.beginFast(),
4769
_bz_VecExprConstant<int>(d3)));
4770
}
4771
4772
// where(Range, Vector<P_numtype2>, float)
4773
template<class P_numtype2>
4774
inline
4775
_bz_VecExpr<_bz_VecWhere<Range,
4776
VectorIterConst<P_numtype2>,
4777
_bz_VecExprConstant<float> > >
4778
where(Range d1,
4779
const Vector<P_numtype2>& d2,
4780
float d3)
4781
{
4782
typedef _bz_VecWhere<Range,
4783
VectorIterConst<P_numtype2>,
4784
_bz_VecExprConstant<float> > T_expr;
4785
4786
return _bz_VecExpr<T_expr>(T_expr(d1,
4787
d2.beginFast(),
4788
_bz_VecExprConstant<float>(d3)));
4789
}
4790
4791
// where(Range, Vector<P_numtype2>, double)
4792
template<class P_numtype2>
4793
inline
4794
_bz_VecExpr<_bz_VecWhere<Range,
4795
VectorIterConst<P_numtype2>,
4796
_bz_VecExprConstant<double> > >
4797
where(Range d1,
4798
const Vector<P_numtype2>& d2,
4799
double d3)
4800
{
4801
typedef _bz_VecWhere<Range,
4802
VectorIterConst<P_numtype2>,
4803
_bz_VecExprConstant<double> > T_expr;
4804
4805
return _bz_VecExpr<T_expr>(T_expr(d1,
4806
d2.beginFast(),
4807
_bz_VecExprConstant<double>(d3)));
4808
}
4809
4810
// where(Range, Vector<P_numtype2>, long double)
4811
template<class P_numtype2>
4812
inline
4813
_bz_VecExpr<_bz_VecWhere<Range,
4814
VectorIterConst<P_numtype2>,
4815
_bz_VecExprConstant<long double> > >
4816
where(Range d1,
4817
const Vector<P_numtype2>& d2,
4818
long double d3)
4819
{
4820
typedef _bz_VecWhere<Range,
4821
VectorIterConst<P_numtype2>,
4822
_bz_VecExprConstant<long double> > T_expr;
4823
4824
return _bz_VecExpr<T_expr>(T_expr(d1,
4825
d2.beginFast(),
4826
_bz_VecExprConstant<long double>(d3)));
4827
}
4828
4829
// where(Range, Vector<P_numtype2>, complex<T3>)
4830
#ifdef BZ_HAVE_COMPLEX
4831
template<class P_numtype2, class T3>
4832
inline
4833
_bz_VecExpr<_bz_VecWhere<Range,
4834
VectorIterConst<P_numtype2>,
4835
_bz_VecExprConstant<complex<T3> > > >
4836
where(Range d1,
4837
const Vector<P_numtype2>& d2,
4838
complex<T3> d3)
4839
{
4840
typedef _bz_VecWhere<Range,
4841
VectorIterConst<P_numtype2>,
4842
_bz_VecExprConstant<complex<T3> > > T_expr;
4843
4844
return _bz_VecExpr<T_expr>(T_expr(d1,
4845
d2.beginFast(),
4846
_bz_VecExprConstant<complex<T3> > (d3)));
4847
}
4848
#endif // BZ_HAVE_COMPLEX
4849
4850
// where(Range, _bz_VecExpr<P_expr2>, Vector<P_numtype3>)
4851
template<class P_expr2, class P_numtype3>
4852
inline
4853
_bz_VecExpr<_bz_VecWhere<Range,
4854
_bz_VecExpr<P_expr2>,
4855
VectorIterConst<P_numtype3> > >
4856
where(Range d1,
4857
_bz_VecExpr<P_expr2> d2,
4858
const Vector<P_numtype3>& d3)
4859
{
4860
typedef _bz_VecWhere<Range,
4861
_bz_VecExpr<P_expr2>,
4862
VectorIterConst<P_numtype3> > T_expr;
4863
4864
return _bz_VecExpr<T_expr>(T_expr(d1,
4865
d2,
4866
d3.beginFast()));
4867
}
4868
4869
// where(Range, _bz_VecExpr<P_expr2>, _bz_VecExpr<P_expr3>)
4870
template<class P_expr2, class P_expr3>
4871
inline
4872
_bz_VecExpr<_bz_VecWhere<Range,
4873
_bz_VecExpr<P_expr2>,
4874
_bz_VecExpr<P_expr3> > >
4875
where(Range d1,
4876
_bz_VecExpr<P_expr2> d2,
4877
_bz_VecExpr<P_expr3> d3)
4878
{
4879
typedef _bz_VecWhere<Range,
4880
_bz_VecExpr<P_expr2>,
4881
_bz_VecExpr<P_expr3> > T_expr;
4882
4883
return _bz_VecExpr<T_expr>(T_expr(d1,
4884
d2,
4885
d3));
4886
}
4887
4888
// where(Range, _bz_VecExpr<P_expr2>, VectorPick<P_numtype3>)
4889
template<class P_expr2, class P_numtype3>
4890
inline
4891
_bz_VecExpr<_bz_VecWhere<Range,
4892
_bz_VecExpr<P_expr2>,
4893
VectorPickIterConst<P_numtype3> > >
4894
where(Range d1,
4895
_bz_VecExpr<P_expr2> d2,
4896
const VectorPick<P_numtype3>& d3)
4897
{
4898
typedef _bz_VecWhere<Range,
4899
_bz_VecExpr<P_expr2>,
4900
VectorPickIterConst<P_numtype3> > T_expr;
4901
4902
return _bz_VecExpr<T_expr>(T_expr(d1,
4903
d2,
4904
d3.beginFast()));
4905
}
4906
4907
// where(Range, _bz_VecExpr<P_expr2>, Range)
4908
template<class P_expr2>
4909
inline
4910
_bz_VecExpr<_bz_VecWhere<Range,
4911
_bz_VecExpr<P_expr2>,
4912
Range > >
4913
where(Range d1,
4914
_bz_VecExpr<P_expr2> d2,
4915
Range d3)
4916
{
4917
typedef _bz_VecWhere<Range,
4918
_bz_VecExpr<P_expr2>,
4919
Range > T_expr;
4920
4921
return _bz_VecExpr<T_expr>(T_expr(d1,
4922
d2,
4923
d3));
4924
}
4925
4926
// where(Range, _bz_VecExpr<P_expr2>, TinyVector<P_numtype3, N_length3>)
4927
template<class P_expr2, class P_numtype3, int N_length3>
4928
inline
4929
_bz_VecExpr<_bz_VecWhere<Range,
4930
_bz_VecExpr<P_expr2>,
4931
TinyVectorIterConst<P_numtype3, N_length3> > >
4932
where(Range d1,
4933
_bz_VecExpr<P_expr2> d2,
4934
const TinyVector<P_numtype3, N_length3>& d3)
4935
{
4936
typedef _bz_VecWhere<Range,
4937
_bz_VecExpr<P_expr2>,
4938
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
4939
4940
return _bz_VecExpr<T_expr>(T_expr(d1,
4941
d2,
4942
d3.beginFast()));
4943
}
4944
4945
// where(Range, _bz_VecExpr<P_expr2>, int)
4946
template<class P_expr2>
4947
inline
4948
_bz_VecExpr<_bz_VecWhere<Range,
4949
_bz_VecExpr<P_expr2>,
4950
_bz_VecExprConstant<int> > >
4951
where(Range d1,
4952
_bz_VecExpr<P_expr2> d2,
4953
int d3)
4954
{
4955
typedef _bz_VecWhere<Range,
4956
_bz_VecExpr<P_expr2>,
4957
_bz_VecExprConstant<int> > T_expr;
4958
4959
return _bz_VecExpr<T_expr>(T_expr(d1,
4960
d2,
4961
_bz_VecExprConstant<int>(d3)));
4962
}
4963
4964
// where(Range, _bz_VecExpr<P_expr2>, float)
4965
template<class P_expr2>
4966
inline
4967
_bz_VecExpr<_bz_VecWhere<Range,
4968
_bz_VecExpr<P_expr2>,
4969
_bz_VecExprConstant<float> > >
4970
where(Range d1,
4971
_bz_VecExpr<P_expr2> d2,
4972
float d3)
4973
{
4974
typedef _bz_VecWhere<Range,
4975
_bz_VecExpr<P_expr2>,
4976
_bz_VecExprConstant<float> > T_expr;
4977
4978
return _bz_VecExpr<T_expr>(T_expr(d1,
4979
d2,
4980
_bz_VecExprConstant<float>(d3)));
4981
}
4982
4983
// where(Range, _bz_VecExpr<P_expr2>, double)
4984
template<class P_expr2>
4985
inline
4986
_bz_VecExpr<_bz_VecWhere<Range,
4987
_bz_VecExpr<P_expr2>,
4988
_bz_VecExprConstant<double> > >
4989
where(Range d1,
4990
_bz_VecExpr<P_expr2> d2,
4991
double d3)
4992
{
4993
typedef _bz_VecWhere<Range,
4994
_bz_VecExpr<P_expr2>,
4995
_bz_VecExprConstant<double> > T_expr;
4996
4997
return _bz_VecExpr<T_expr>(T_expr(d1,
4998
d2,
4999
_bz_VecExprConstant<double>(d3)));
5000
}
5001
5002
// where(Range, _bz_VecExpr<P_expr2>, long double)
5003
template<class P_expr2>
5004
inline
5005
_bz_VecExpr<_bz_VecWhere<Range,
5006
_bz_VecExpr<P_expr2>,
5007
_bz_VecExprConstant<long double> > >
5008
where(Range d1,
5009
_bz_VecExpr<P_expr2> d2,
5010
long double d3)
5011
{
5012
typedef _bz_VecWhere<Range,
5013
_bz_VecExpr<P_expr2>,
5014
_bz_VecExprConstant<long double> > T_expr;
5015
5016
return _bz_VecExpr<T_expr>(T_expr(d1,
5017
d2,
5018
_bz_VecExprConstant<long double>(d3)));
5019
}
5020
5021
// where(Range, _bz_VecExpr<P_expr2>, complex<T3>)
5022
#ifdef BZ_HAVE_COMPLEX
5023
template<class P_expr2, class T3>
5024
inline
5025
_bz_VecExpr<_bz_VecWhere<Range,
5026
_bz_VecExpr<P_expr2>,
5027
_bz_VecExprConstant<complex<T3> > > >
5028
where(Range d1,
5029
_bz_VecExpr<P_expr2> d2,
5030
complex<T3> d3)
5031
{
5032
typedef _bz_VecWhere<Range,
5033
_bz_VecExpr<P_expr2>,
5034
_bz_VecExprConstant<complex<T3> > > T_expr;
5035
5036
return _bz_VecExpr<T_expr>(T_expr(d1,
5037
d2,
5038
_bz_VecExprConstant<complex<T3> > (d3)));
5039
}
5040
#endif // BZ_HAVE_COMPLEX
5041
5042
// where(Range, VectorPick<P_numtype2>, Vector<P_numtype3>)
5043
template<class P_numtype2, class P_numtype3>
5044
inline
5045
_bz_VecExpr<_bz_VecWhere<Range,
5046
VectorPickIterConst<P_numtype2>,
5047
VectorIterConst<P_numtype3> > >
5048
where(Range d1,
5049
const VectorPick<P_numtype2>& d2,
5050
const Vector<P_numtype3>& d3)
5051
{
5052
typedef _bz_VecWhere<Range,
5053
VectorPickIterConst<P_numtype2>,
5054
VectorIterConst<P_numtype3> > T_expr;
5055
5056
return _bz_VecExpr<T_expr>(T_expr(d1,
5057
d2.beginFast(),
5058
d3.beginFast()));
5059
}
5060
5061
// where(Range, VectorPick<P_numtype2>, _bz_VecExpr<P_expr3>)
5062
template<class P_numtype2, class P_expr3>
5063
inline
5064
_bz_VecExpr<_bz_VecWhere<Range,
5065
VectorPickIterConst<P_numtype2>,
5066
_bz_VecExpr<P_expr3> > >
5067
where(Range d1,
5068
const VectorPick<P_numtype2>& d2,
5069
_bz_VecExpr<P_expr3> d3)
5070
{
5071
typedef _bz_VecWhere<Range,
5072
VectorPickIterConst<P_numtype2>,
5073
_bz_VecExpr<P_expr3> > T_expr;
5074
5075
return _bz_VecExpr<T_expr>(T_expr(d1,
5076
d2.beginFast(),
5077
d3));
5078
}
5079
5080
// where(Range, VectorPick<P_numtype2>, VectorPick<P_numtype3>)
5081
template<class P_numtype2, class P_numtype3>
5082
inline
5083
_bz_VecExpr<_bz_VecWhere<Range,
5084
VectorPickIterConst<P_numtype2>,
5085
VectorPickIterConst<P_numtype3> > >
5086
where(Range d1,
5087
const VectorPick<P_numtype2>& d2,
5088
const VectorPick<P_numtype3>& d3)
5089
{
5090
typedef _bz_VecWhere<Range,
5091
VectorPickIterConst<P_numtype2>,
5092
VectorPickIterConst<P_numtype3> > T_expr;
5093
5094
return _bz_VecExpr<T_expr>(T_expr(d1,
5095
d2.beginFast(),
5096
d3.beginFast()));
5097
}
5098
5099
// where(Range, VectorPick<P_numtype2>, Range)
5100
template<class P_numtype2>
5101
inline
5102
_bz_VecExpr<_bz_VecWhere<Range,
5103
VectorPickIterConst<P_numtype2>,
5104
Range > >
5105
where(Range d1,
5106
const VectorPick<P_numtype2>& d2,
5107
Range d3)
5108
{
5109
typedef _bz_VecWhere<Range,
5110
VectorPickIterConst<P_numtype2>,
5111
Range > T_expr;
5112
5113
return _bz_VecExpr<T_expr>(T_expr(d1,
5114
d2.beginFast(),
5115
d3));
5116
}
5117
5118
// where(Range, VectorPick<P_numtype2>, TinyVector<P_numtype3, N_length3>)
5119
template<class P_numtype2, class P_numtype3, int N_length3>
5120
inline
5121
_bz_VecExpr<_bz_VecWhere<Range,
5122
VectorPickIterConst<P_numtype2>,
5123
TinyVectorIterConst<P_numtype3, N_length3> > >
5124
where(Range d1,
5125
const VectorPick<P_numtype2>& d2,
5126
const TinyVector<P_numtype3, N_length3>& d3)
5127
{
5128
typedef _bz_VecWhere<Range,
5129
VectorPickIterConst<P_numtype2>,
5130
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
5131
5132
return _bz_VecExpr<T_expr>(T_expr(d1,
5133
d2.beginFast(),
5134
d3.beginFast()));
5135
}
5136
5137
// where(Range, VectorPick<P_numtype2>, int)
5138
template<class P_numtype2>
5139
inline
5140
_bz_VecExpr<_bz_VecWhere<Range,
5141
VectorPickIterConst<P_numtype2>,
5142
_bz_VecExprConstant<int> > >
5143
where(Range d1,
5144
const VectorPick<P_numtype2>& d2,
5145
int d3)
5146
{
5147
typedef _bz_VecWhere<Range,
5148
VectorPickIterConst<P_numtype2>,
5149
_bz_VecExprConstant<int> > T_expr;
5150
5151
return _bz_VecExpr<T_expr>(T_expr(d1,
5152
d2.beginFast(),
5153
_bz_VecExprConstant<int>(d3)));
5154
}
5155
5156
// where(Range, VectorPick<P_numtype2>, float)
5157
template<class P_numtype2>
5158
inline
5159
_bz_VecExpr<_bz_VecWhere<Range,
5160
VectorPickIterConst<P_numtype2>,
5161
_bz_VecExprConstant<float> > >
5162
where(Range d1,
5163
const VectorPick<P_numtype2>& d2,
5164
float d3)
5165
{
5166
typedef _bz_VecWhere<Range,
5167
VectorPickIterConst<P_numtype2>,
5168
_bz_VecExprConstant<float> > T_expr;
5169
5170
return _bz_VecExpr<T_expr>(T_expr(d1,
5171
d2.beginFast(),
5172
_bz_VecExprConstant<float>(d3)));
5173
}
5174
5175
// where(Range, VectorPick<P_numtype2>, double)
5176
template<class P_numtype2>
5177
inline
5178
_bz_VecExpr<_bz_VecWhere<Range,
5179
VectorPickIterConst<P_numtype2>,
5180
_bz_VecExprConstant<double> > >
5181
where(Range d1,
5182
const VectorPick<P_numtype2>& d2,
5183
double d3)
5184
{
5185
typedef _bz_VecWhere<Range,
5186
VectorPickIterConst<P_numtype2>,
5187
_bz_VecExprConstant<double> > T_expr;
5188
5189
return _bz_VecExpr<T_expr>(T_expr(d1,
5190
d2.beginFast(),
5191
_bz_VecExprConstant<double>(d3)));
5192
}
5193
5194
// where(Range, VectorPick<P_numtype2>, long double)
5195
template<class P_numtype2>
5196
inline
5197
_bz_VecExpr<_bz_VecWhere<Range,
5198
VectorPickIterConst<P_numtype2>,
5199
_bz_VecExprConstant<long double> > >
5200
where(Range d1,
5201
const VectorPick<P_numtype2>& d2,
5202
long double d3)
5203
{
5204
typedef _bz_VecWhere<Range,
5205
VectorPickIterConst<P_numtype2>,
5206
_bz_VecExprConstant<long double> > T_expr;
5207
5208
return _bz_VecExpr<T_expr>(T_expr(d1,
5209
d2.beginFast(),
5210
_bz_VecExprConstant<long double>(d3)));
5211
}
5212
5213
// where(Range, VectorPick<P_numtype2>, complex<T3>)
5214
#ifdef BZ_HAVE_COMPLEX
5215
template<class P_numtype2, class T3>
5216
inline
5217
_bz_VecExpr<_bz_VecWhere<Range,
5218
VectorPickIterConst<P_numtype2>,
5219
_bz_VecExprConstant<complex<T3> > > >
5220
where(Range d1,
5221
const VectorPick<P_numtype2>& d2,
5222
complex<T3> d3)
5223
{
5224
typedef _bz_VecWhere<Range,
5225
VectorPickIterConst<P_numtype2>,
5226
_bz_VecExprConstant<complex<T3> > > T_expr;
5227
5228
return _bz_VecExpr<T_expr>(T_expr(d1,
5229
d2.beginFast(),
5230
_bz_VecExprConstant<complex<T3> > (d3)));
5231
}
5232
#endif // BZ_HAVE_COMPLEX
5233
5234
// where(Range, Range, Vector<P_numtype3>)
5235
template<class P_numtype3>
5236
inline
5237
_bz_VecExpr<_bz_VecWhere<Range,
5238
Range,
5239
VectorIterConst<P_numtype3> > >
5240
where(Range d1,
5241
Range d2,
5242
const Vector<P_numtype3>& d3)
5243
{
5244
typedef _bz_VecWhere<Range,
5245
Range,
5246
VectorIterConst<P_numtype3> > T_expr;
5247
5248
return _bz_VecExpr<T_expr>(T_expr(d1,
5249
d2,
5250
d3.beginFast()));
5251
}
5252
5253
// where(Range, Range, _bz_VecExpr<P_expr3>)
5254
template<class P_expr3>
5255
inline
5256
_bz_VecExpr<_bz_VecWhere<Range,
5257
Range,
5258
_bz_VecExpr<P_expr3> > >
5259
where(Range d1,
5260
Range d2,
5261
_bz_VecExpr<P_expr3> d3)
5262
{
5263
typedef _bz_VecWhere<Range,
5264
Range,
5265
_bz_VecExpr<P_expr3> > T_expr;
5266
5267
return _bz_VecExpr<T_expr>(T_expr(d1,
5268
d2,
5269
d3));
5270
}
5271
5272
// where(Range, Range, VectorPick<P_numtype3>)
5273
template<class P_numtype3>
5274
inline
5275
_bz_VecExpr<_bz_VecWhere<Range,
5276
Range,
5277
VectorPickIterConst<P_numtype3> > >
5278
where(Range d1,
5279
Range d2,
5280
const VectorPick<P_numtype3>& d3)
5281
{
5282
typedef _bz_VecWhere<Range,
5283
Range,
5284
VectorPickIterConst<P_numtype3> > T_expr;
5285
5286
return _bz_VecExpr<T_expr>(T_expr(d1,
5287
d2,
5288
d3.beginFast()));
5289
}
5290
5291
// where(Range, Range, Range)
5292
5293
inline
5294
_bz_VecExpr<_bz_VecWhere<Range,
5295
Range,
5296
Range > >
5297
where(Range d1,
5298
Range d2,
5299
Range d3)
5300
{
5301
typedef _bz_VecWhere<Range,
5302
Range,
5303
Range > T_expr;
5304
5305
return _bz_VecExpr<T_expr>(T_expr(d1,
5306
d2,
5307
d3));
5308
}
5309
5310
// where(Range, Range, TinyVector<P_numtype3, N_length3>)
5311
template<class P_numtype3, int N_length3>
5312
inline
5313
_bz_VecExpr<_bz_VecWhere<Range,
5314
Range,
5315
TinyVectorIterConst<P_numtype3, N_length3> > >
5316
where(Range d1,
5317
Range d2,
5318
const TinyVector<P_numtype3, N_length3>& d3)
5319
{
5320
typedef _bz_VecWhere<Range,
5321
Range,
5322
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
5323
5324
return _bz_VecExpr<T_expr>(T_expr(d1,
5325
d2,
5326
d3.beginFast()));
5327
}
5328
5329
// where(Range, Range, int)
5330
5331
inline
5332
_bz_VecExpr<_bz_VecWhere<Range,
5333
Range,
5334
_bz_VecExprConstant<int> > >
5335
where(Range d1,
5336
Range d2,
5337
int d3)
5338
{
5339
typedef _bz_VecWhere<Range,
5340
Range,
5341
_bz_VecExprConstant<int> > T_expr;
5342
5343
return _bz_VecExpr<T_expr>(T_expr(d1,
5344
d2,
5345
_bz_VecExprConstant<int>(d3)));
5346
}
5347
5348
// where(Range, Range, float)
5349
5350
inline
5351
_bz_VecExpr<_bz_VecWhere<Range,
5352
Range,
5353
_bz_VecExprConstant<float> > >
5354
where(Range d1,
5355
Range d2,
5356
float d3)
5357
{
5358
typedef _bz_VecWhere<Range,
5359
Range,
5360
_bz_VecExprConstant<float> > T_expr;
5361
5362
return _bz_VecExpr<T_expr>(T_expr(d1,
5363
d2,
5364
_bz_VecExprConstant<float>(d3)));
5365
}
5366
5367
// where(Range, Range, double)
5368
5369
inline
5370
_bz_VecExpr<_bz_VecWhere<Range,
5371
Range,
5372
_bz_VecExprConstant<double> > >
5373
where(Range d1,
5374
Range d2,
5375
double d3)
5376
{
5377
typedef _bz_VecWhere<Range,
5378
Range,
5379
_bz_VecExprConstant<double> > T_expr;
5380
5381
return _bz_VecExpr<T_expr>(T_expr(d1,
5382
d2,
5383
_bz_VecExprConstant<double>(d3)));
5384
}
5385
5386
// where(Range, Range, long double)
5387
5388
inline
5389
_bz_VecExpr<_bz_VecWhere<Range,
5390
Range,
5391
_bz_VecExprConstant<long double> > >
5392
where(Range d1,
5393
Range d2,
5394
long double d3)
5395
{
5396
typedef _bz_VecWhere<Range,
5397
Range,
5398
_bz_VecExprConstant<long double> > T_expr;
5399
5400
return _bz_VecExpr<T_expr>(T_expr(d1,
5401
d2,
5402
_bz_VecExprConstant<long double>(d3)));
5403
}
5404
5405
// where(Range, Range, complex<T3>)
5406
#ifdef BZ_HAVE_COMPLEX
5407
template<class T3>
5408
inline
5409
_bz_VecExpr<_bz_VecWhere<Range,
5410
Range,
5411
_bz_VecExprConstant<complex<T3> > > >
5412
where(Range d1,
5413
Range d2,
5414
complex<T3> d3)
5415
{
5416
typedef _bz_VecWhere<Range,
5417
Range,
5418
_bz_VecExprConstant<complex<T3> > > T_expr;
5419
5420
return _bz_VecExpr<T_expr>(T_expr(d1,
5421
d2,
5422
_bz_VecExprConstant<complex<T3> > (d3)));
5423
}
5424
#endif // BZ_HAVE_COMPLEX
5425
5426
// where(Range, TinyVector<P_numtype2, N_length2>, Vector<P_numtype3>)
5427
template<class P_numtype2, int N_length2, class P_numtype3>
5428
inline
5429
_bz_VecExpr<_bz_VecWhere<Range,
5430
TinyVectorIterConst<P_numtype2, N_length2>,
5431
VectorIterConst<P_numtype3> > >
5432
where(Range d1,
5433
const TinyVector<P_numtype2, N_length2>& d2,
5434
const Vector<P_numtype3>& d3)
5435
{
5436
typedef _bz_VecWhere<Range,
5437
TinyVectorIterConst<P_numtype2, N_length2>,
5438
VectorIterConst<P_numtype3> > T_expr;
5439
5440
return _bz_VecExpr<T_expr>(T_expr(d1,
5441
d2.beginFast(),
5442
d3.beginFast()));
5443
}
5444
5445
// where(Range, TinyVector<P_numtype2, N_length2>, _bz_VecExpr<P_expr3>)
5446
template<class P_numtype2, int N_length2, class P_expr3>
5447
inline
5448
_bz_VecExpr<_bz_VecWhere<Range,
5449
TinyVectorIterConst<P_numtype2, N_length2>,
5450
_bz_VecExpr<P_expr3> > >
5451
where(Range d1,
5452
const TinyVector<P_numtype2, N_length2>& d2,
5453
_bz_VecExpr<P_expr3> d3)
5454
{
5455
typedef _bz_VecWhere<Range,
5456
TinyVectorIterConst<P_numtype2, N_length2>,
5457
_bz_VecExpr<P_expr3> > T_expr;
5458
5459
return _bz_VecExpr<T_expr>(T_expr(d1,
5460
d2.beginFast(),
5461
d3));
5462
}
5463
5464
// where(Range, TinyVector<P_numtype2, N_length2>, VectorPick<P_numtype3>)
5465
template<class P_numtype2, int N_length2, class P_numtype3>
5466
inline
5467
_bz_VecExpr<_bz_VecWhere<Range,
5468
TinyVectorIterConst<P_numtype2, N_length2>,
5469
VectorPickIterConst<P_numtype3> > >
5470
where(Range d1,
5471
const TinyVector<P_numtype2, N_length2>& d2,
5472
const VectorPick<P_numtype3>& d3)
5473
{
5474
typedef _bz_VecWhere<Range,
5475
TinyVectorIterConst<P_numtype2, N_length2>,
5476
VectorPickIterConst<P_numtype3> > T_expr;
5477
5478
return _bz_VecExpr<T_expr>(T_expr(d1,
5479
d2.beginFast(),
5480
d3.beginFast()));
5481
}
5482
5483
// where(Range, TinyVector<P_numtype2, N_length2>, Range)
5484
template<class P_numtype2, int N_length2>
5485
inline
5486
_bz_VecExpr<_bz_VecWhere<Range,
5487
TinyVectorIterConst<P_numtype2, N_length2>,
5488
Range > >
5489
where(Range d1,
5490
const TinyVector<P_numtype2, N_length2>& d2,
5491
Range d3)
5492
{
5493
typedef _bz_VecWhere<Range,
5494
TinyVectorIterConst<P_numtype2, N_length2>,
5495
Range > T_expr;
5496
5497
return _bz_VecExpr<T_expr>(T_expr(d1,
5498
d2.beginFast(),
5499
d3));
5500
}
5501
5502
// where(Range, TinyVector<P_numtype2, N_length2>, TinyVector<P_numtype3, N_length3>)
5503
template<class P_numtype2, int N_length2, class P_numtype3, int N_length3>
5504
inline
5505
_bz_VecExpr<_bz_VecWhere<Range,
5506
TinyVectorIterConst<P_numtype2, N_length2>,
5507
TinyVectorIterConst<P_numtype3, N_length3> > >
5508
where(Range d1,
5509
const TinyVector<P_numtype2, N_length2>& d2,
5510
const TinyVector<P_numtype3, N_length3>& d3)
5511
{
5512
typedef _bz_VecWhere<Range,
5513
TinyVectorIterConst<P_numtype2, N_length2>,
5514
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
5515
5516
return _bz_VecExpr<T_expr>(T_expr(d1,
5517
d2.beginFast(),
5518
d3.beginFast()));
5519
}
5520
5521
// where(Range, TinyVector<P_numtype2, N_length2>, int)
5522
template<class P_numtype2, int N_length2>
5523
inline
5524
_bz_VecExpr<_bz_VecWhere<Range,
5525
TinyVectorIterConst<P_numtype2, N_length2>,
5526
_bz_VecExprConstant<int> > >
5527
where(Range d1,
5528
const TinyVector<P_numtype2, N_length2>& d2,
5529
int d3)
5530
{
5531
typedef _bz_VecWhere<Range,
5532
TinyVectorIterConst<P_numtype2, N_length2>,
5533
_bz_VecExprConstant<int> > T_expr;
5534
5535
return _bz_VecExpr<T_expr>(T_expr(d1,
5536
d2.beginFast(),
5537
_bz_VecExprConstant<int>(d3)));
5538
}
5539
5540
// where(Range, TinyVector<P_numtype2, N_length2>, float)
5541
template<class P_numtype2, int N_length2>
5542
inline
5543
_bz_VecExpr<_bz_VecWhere<Range,
5544
TinyVectorIterConst<P_numtype2, N_length2>,
5545
_bz_VecExprConstant<float> > >
5546
where(Range d1,
5547
const TinyVector<P_numtype2, N_length2>& d2,
5548
float d3)
5549
{
5550
typedef _bz_VecWhere<Range,
5551
TinyVectorIterConst<P_numtype2, N_length2>,
5552
_bz_VecExprConstant<float> > T_expr;
5553
5554
return _bz_VecExpr<T_expr>(T_expr(d1,
5555
d2.beginFast(),
5556
_bz_VecExprConstant<float>(d3)));
5557
}
5558
5559
// where(Range, TinyVector<P_numtype2, N_length2>, double)
5560
template<class P_numtype2, int N_length2>
5561
inline
5562
_bz_VecExpr<_bz_VecWhere<Range,
5563
TinyVectorIterConst<P_numtype2, N_length2>,
5564
_bz_VecExprConstant<double> > >
5565
where(Range d1,
5566
const TinyVector<P_numtype2, N_length2>& d2,
5567
double d3)
5568
{
5569
typedef _bz_VecWhere<Range,
5570
TinyVectorIterConst<P_numtype2, N_length2>,
5571
_bz_VecExprConstant<double> > T_expr;
5572
5573
return _bz_VecExpr<T_expr>(T_expr(d1,
5574
d2.beginFast(),
5575
_bz_VecExprConstant<double>(d3)));
5576
}
5577
5578
// where(Range, TinyVector<P_numtype2, N_length2>, long double)
5579
template<class P_numtype2, int N_length2>
5580
inline
5581
_bz_VecExpr<_bz_VecWhere<Range,
5582
TinyVectorIterConst<P_numtype2, N_length2>,
5583
_bz_VecExprConstant<long double> > >
5584
where(Range d1,
5585
const TinyVector<P_numtype2, N_length2>& d2,
5586
long double d3)
5587
{
5588
typedef _bz_VecWhere<Range,
5589
TinyVectorIterConst<P_numtype2, N_length2>,
5590
_bz_VecExprConstant<long double> > T_expr;
5591
5592
return _bz_VecExpr<T_expr>(T_expr(d1,
5593
d2.beginFast(),
5594
_bz_VecExprConstant<long double>(d3)));
5595
}
5596
5597
// where(Range, TinyVector<P_numtype2, N_length2>, complex<T3>)
5598
#ifdef BZ_HAVE_COMPLEX
5599
template<class P_numtype2, int N_length2, class T3>
5600
inline
5601
_bz_VecExpr<_bz_VecWhere<Range,
5602
TinyVectorIterConst<P_numtype2, N_length2>,
5603
_bz_VecExprConstant<complex<T3> > > >
5604
where(Range d1,
5605
const TinyVector<P_numtype2, N_length2>& d2,
5606
complex<T3> d3)
5607
{
5608
typedef _bz_VecWhere<Range,
5609
TinyVectorIterConst<P_numtype2, N_length2>,
5610
_bz_VecExprConstant<complex<T3> > > T_expr;
5611
5612
return _bz_VecExpr<T_expr>(T_expr(d1,
5613
d2.beginFast(),
5614
_bz_VecExprConstant<complex<T3> > (d3)));
5615
}
5616
#endif // BZ_HAVE_COMPLEX
5617
5618
// where(Range, int, Vector<P_numtype3>)
5619
template<class P_numtype3>
5620
inline
5621
_bz_VecExpr<_bz_VecWhere<Range,
5622
_bz_VecExprConstant<int>,
5623
VectorIterConst<P_numtype3> > >
5624
where(Range d1,
5625
int d2,
5626
const Vector<P_numtype3>& d3)
5627
{
5628
typedef _bz_VecWhere<Range,
5629
_bz_VecExprConstant<int>,
5630
VectorIterConst<P_numtype3> > T_expr;
5631
5632
return _bz_VecExpr<T_expr>(T_expr(d1,
5633
_bz_VecExprConstant<int>(d2),
5634
d3.beginFast()));
5635
}
5636
5637
// where(Range, int, _bz_VecExpr<P_expr3>)
5638
template<class P_expr3>
5639
inline
5640
_bz_VecExpr<_bz_VecWhere<Range,
5641
_bz_VecExprConstant<int>,
5642
_bz_VecExpr<P_expr3> > >
5643
where(Range d1,
5644
int d2,
5645
_bz_VecExpr<P_expr3> d3)
5646
{
5647
typedef _bz_VecWhere<Range,
5648
_bz_VecExprConstant<int>,
5649
_bz_VecExpr<P_expr3> > T_expr;
5650
5651
return _bz_VecExpr<T_expr>(T_expr(d1,
5652
_bz_VecExprConstant<int>(d2),
5653
d3));
5654
}
5655
5656
// where(Range, int, VectorPick<P_numtype3>)
5657
template<class P_numtype3>
5658
inline
5659
_bz_VecExpr<_bz_VecWhere<Range,
5660
_bz_VecExprConstant<int>,
5661
VectorPickIterConst<P_numtype3> > >
5662
where(Range d1,
5663
int d2,
5664
const VectorPick<P_numtype3>& d3)
5665
{
5666
typedef _bz_VecWhere<Range,
5667
_bz_VecExprConstant<int>,
5668
VectorPickIterConst<P_numtype3> > T_expr;
5669
5670
return _bz_VecExpr<T_expr>(T_expr(d1,
5671
_bz_VecExprConstant<int>(d2),
5672
d3.beginFast()));
5673
}
5674
5675
// where(Range, int, Range)
5676
5677
inline
5678
_bz_VecExpr<_bz_VecWhere<Range,
5679
_bz_VecExprConstant<int>,
5680
Range > >
5681
where(Range d1,
5682
int d2,
5683
Range d3)
5684
{
5685
typedef _bz_VecWhere<Range,
5686
_bz_VecExprConstant<int>,
5687
Range > T_expr;
5688
5689
return _bz_VecExpr<T_expr>(T_expr(d1,
5690
_bz_VecExprConstant<int>(d2),
5691
d3));
5692
}
5693
5694
// where(Range, int, TinyVector<P_numtype3, N_length3>)
5695
template<class P_numtype3, int N_length3>
5696
inline
5697
_bz_VecExpr<_bz_VecWhere<Range,
5698
_bz_VecExprConstant<int>,
5699
TinyVectorIterConst<P_numtype3, N_length3> > >
5700
where(Range d1,
5701
int d2,
5702
const TinyVector<P_numtype3, N_length3>& d3)
5703
{
5704
typedef _bz_VecWhere<Range,
5705
_bz_VecExprConstant<int>,
5706
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
5707
5708
return _bz_VecExpr<T_expr>(T_expr(d1,
5709
_bz_VecExprConstant<int>(d2),
5710
d3.beginFast()));
5711
}
5712
5713
// where(Range, int, int)
5714
5715
inline
5716
_bz_VecExpr<_bz_VecWhere<Range,
5717
_bz_VecExprConstant<int>,
5718
_bz_VecExprConstant<int> > >
5719
where(Range d1,
5720
int d2,
5721
int d3)
5722
{
5723
typedef _bz_VecWhere<Range,
5724
_bz_VecExprConstant<int>,
5725
_bz_VecExprConstant<int> > T_expr;
5726
5727
return _bz_VecExpr<T_expr>(T_expr(d1,
5728
_bz_VecExprConstant<int>(d2),
5729
_bz_VecExprConstant<int>(d3)));
5730
}
5731
5732
// where(Range, float, Vector<P_numtype3>)
5733
template<class P_numtype3>
5734
inline
5735
_bz_VecExpr<_bz_VecWhere<Range,
5736
_bz_VecExprConstant<float>,
5737
VectorIterConst<P_numtype3> > >
5738
where(Range d1,
5739
float d2,
5740
const Vector<P_numtype3>& d3)
5741
{
5742
typedef _bz_VecWhere<Range,
5743
_bz_VecExprConstant<float>,
5744
VectorIterConst<P_numtype3> > T_expr;
5745
5746
return _bz_VecExpr<T_expr>(T_expr(d1,
5747
_bz_VecExprConstant<float>(d2),
5748
d3.beginFast()));
5749
}
5750
5751
// where(Range, float, _bz_VecExpr<P_expr3>)
5752
template<class P_expr3>
5753
inline
5754
_bz_VecExpr<_bz_VecWhere<Range,
5755
_bz_VecExprConstant<float>,
5756
_bz_VecExpr<P_expr3> > >
5757
where(Range d1,
5758
float d2,
5759
_bz_VecExpr<P_expr3> d3)
5760
{
5761
typedef _bz_VecWhere<Range,
5762
_bz_VecExprConstant<float>,
5763
_bz_VecExpr<P_expr3> > T_expr;
5764
5765
return _bz_VecExpr<T_expr>(T_expr(d1,
5766
_bz_VecExprConstant<float>(d2),
5767
d3));
5768
}
5769
5770
// where(Range, float, VectorPick<P_numtype3>)
5771
template<class P_numtype3>
5772
inline
5773
_bz_VecExpr<_bz_VecWhere<Range,
5774
_bz_VecExprConstant<float>,
5775
VectorPickIterConst<P_numtype3> > >
5776
where(Range d1,
5777
float d2,
5778
const VectorPick<P_numtype3>& d3)
5779
{
5780
typedef _bz_VecWhere<Range,
5781
_bz_VecExprConstant<float>,
5782
VectorPickIterConst<P_numtype3> > T_expr;
5783
5784
return _bz_VecExpr<T_expr>(T_expr(d1,
5785
_bz_VecExprConstant<float>(d2),
5786
d3.beginFast()));
5787
}
5788
5789
// where(Range, float, Range)
5790
5791
inline
5792
_bz_VecExpr<_bz_VecWhere<Range,
5793
_bz_VecExprConstant<float>,
5794
Range > >
5795
where(Range d1,
5796
float d2,
5797
Range d3)
5798
{
5799
typedef _bz_VecWhere<Range,
5800
_bz_VecExprConstant<float>,
5801
Range > T_expr;
5802
5803
return _bz_VecExpr<T_expr>(T_expr(d1,
5804
_bz_VecExprConstant<float>(d2),
5805
d3));
5806
}
5807
5808
// where(Range, float, TinyVector<P_numtype3, N_length3>)
5809
template<class P_numtype3, int N_length3>
5810
inline
5811
_bz_VecExpr<_bz_VecWhere<Range,
5812
_bz_VecExprConstant<float>,
5813
TinyVectorIterConst<P_numtype3, N_length3> > >
5814
where(Range d1,
5815
float d2,
5816
const TinyVector<P_numtype3, N_length3>& d3)
5817
{
5818
typedef _bz_VecWhere<Range,
5819
_bz_VecExprConstant<float>,
5820
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
5821
5822
return _bz_VecExpr<T_expr>(T_expr(d1,
5823
_bz_VecExprConstant<float>(d2),
5824
d3.beginFast()));
5825
}
5826
5827
// where(Range, float, float)
5828
5829
inline
5830
_bz_VecExpr<_bz_VecWhere<Range,
5831
_bz_VecExprConstant<float>,
5832
_bz_VecExprConstant<float> > >
5833
where(Range d1,
5834
float d2,
5835
float d3)
5836
{
5837
typedef _bz_VecWhere<Range,
5838
_bz_VecExprConstant<float>,
5839
_bz_VecExprConstant<float> > T_expr;
5840
5841
return _bz_VecExpr<T_expr>(T_expr(d1,
5842
_bz_VecExprConstant<float>(d2),
5843
_bz_VecExprConstant<float>(d3)));
5844
}
5845
5846
// where(Range, double, Vector<P_numtype3>)
5847
template<class P_numtype3>
5848
inline
5849
_bz_VecExpr<_bz_VecWhere<Range,
5850
_bz_VecExprConstant<double>,
5851
VectorIterConst<P_numtype3> > >
5852
where(Range d1,
5853
double d2,
5854
const Vector<P_numtype3>& d3)
5855
{
5856
typedef _bz_VecWhere<Range,
5857
_bz_VecExprConstant<double>,
5858
VectorIterConst<P_numtype3> > T_expr;
5859
5860
return _bz_VecExpr<T_expr>(T_expr(d1,
5861
_bz_VecExprConstant<double>(d2),
5862
d3.beginFast()));
5863
}
5864
5865
// where(Range, double, _bz_VecExpr<P_expr3>)
5866
template<class P_expr3>
5867
inline
5868
_bz_VecExpr<_bz_VecWhere<Range,
5869
_bz_VecExprConstant<double>,
5870
_bz_VecExpr<P_expr3> > >
5871
where(Range d1,
5872
double d2,
5873
_bz_VecExpr<P_expr3> d3)
5874
{
5875
typedef _bz_VecWhere<Range,
5876
_bz_VecExprConstant<double>,
5877
_bz_VecExpr<P_expr3> > T_expr;
5878
5879
return _bz_VecExpr<T_expr>(T_expr(d1,
5880
_bz_VecExprConstant<double>(d2),
5881
d3));
5882
}
5883
5884
// where(Range, double, VectorPick<P_numtype3>)
5885
template<class P_numtype3>
5886
inline
5887
_bz_VecExpr<_bz_VecWhere<Range,
5888
_bz_VecExprConstant<double>,
5889
VectorPickIterConst<P_numtype3> > >
5890
where(Range d1,
5891
double d2,
5892
const VectorPick<P_numtype3>& d3)
5893
{
5894
typedef _bz_VecWhere<Range,
5895
_bz_VecExprConstant<double>,
5896
VectorPickIterConst<P_numtype3> > T_expr;
5897
5898
return _bz_VecExpr<T_expr>(T_expr(d1,
5899
_bz_VecExprConstant<double>(d2),
5900
d3.beginFast()));
5901
}
5902
5903
// where(Range, double, Range)
5904
5905
inline
5906
_bz_VecExpr<_bz_VecWhere<Range,
5907
_bz_VecExprConstant<double>,
5908
Range > >
5909
where(Range d1,
5910
double d2,
5911
Range d3)
5912
{
5913
typedef _bz_VecWhere<Range,
5914
_bz_VecExprConstant<double>,
5915
Range > T_expr;
5916
5917
return _bz_VecExpr<T_expr>(T_expr(d1,
5918
_bz_VecExprConstant<double>(d2),
5919
d3));
5920
}
5921
5922
// where(Range, double, TinyVector<P_numtype3, N_length3>)
5923
template<class P_numtype3, int N_length3>
5924
inline
5925
_bz_VecExpr<_bz_VecWhere<Range,
5926
_bz_VecExprConstant<double>,
5927
TinyVectorIterConst<P_numtype3, N_length3> > >
5928
where(Range d1,
5929
double d2,
5930
const TinyVector<P_numtype3, N_length3>& d3)
5931
{
5932
typedef _bz_VecWhere<Range,
5933
_bz_VecExprConstant<double>,
5934
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
5935
5936
return _bz_VecExpr<T_expr>(T_expr(d1,
5937
_bz_VecExprConstant<double>(d2),
5938
d3.beginFast()));
5939
}
5940
5941
// where(Range, double, double)
5942
5943
inline
5944
_bz_VecExpr<_bz_VecWhere<Range,
5945
_bz_VecExprConstant<double>,
5946
_bz_VecExprConstant<double> > >
5947
where(Range d1,
5948
double d2,
5949
double d3)
5950
{
5951
typedef _bz_VecWhere<Range,
5952
_bz_VecExprConstant<double>,
5953
_bz_VecExprConstant<double> > T_expr;
5954
5955
return _bz_VecExpr<T_expr>(T_expr(d1,
5956
_bz_VecExprConstant<double>(d2),
5957
_bz_VecExprConstant<double>(d3)));
5958
}
5959
5960
// where(Range, long double, Vector<P_numtype3>)
5961
template<class P_numtype3>
5962
inline
5963
_bz_VecExpr<_bz_VecWhere<Range,
5964
_bz_VecExprConstant<long double>,
5965
VectorIterConst<P_numtype3> > >
5966
where(Range d1,
5967
long double d2,
5968
const Vector<P_numtype3>& d3)
5969
{
5970
typedef _bz_VecWhere<Range,
5971
_bz_VecExprConstant<long double>,
5972
VectorIterConst<P_numtype3> > T_expr;
5973
5974
return _bz_VecExpr<T_expr>(T_expr(d1,
5975
_bz_VecExprConstant<long double>(d2),
5976
d3.beginFast()));
5977
}
5978
5979
// where(Range, long double, _bz_VecExpr<P_expr3>)
5980
template<class P_expr3>
5981
inline
5982
_bz_VecExpr<_bz_VecWhere<Range,
5983
_bz_VecExprConstant<long double>,
5984
_bz_VecExpr<P_expr3> > >
5985
where(Range d1,
5986
long double d2,
5987
_bz_VecExpr<P_expr3> d3)
5988
{
5989
typedef _bz_VecWhere<Range,
5990
_bz_VecExprConstant<long double>,
5991
_bz_VecExpr<P_expr3> > T_expr;
5992
5993
return _bz_VecExpr<T_expr>(T_expr(d1,
5994
_bz_VecExprConstant<long double>(d2),
5995
d3));
5996
}
5997
5998
// where(Range, long double, VectorPick<P_numtype3>)
5999
template<class P_numtype3>
6000
inline
6001
_bz_VecExpr<_bz_VecWhere<Range,
6002
_bz_VecExprConstant<long double>,
6003
VectorPickIterConst<P_numtype3> > >
6004
where(Range d1,
6005
long double d2,
6006
const VectorPick<P_numtype3>& d3)
6007
{
6008
typedef _bz_VecWhere<Range,
6009
_bz_VecExprConstant<long double>,
6010
VectorPickIterConst<P_numtype3> > T_expr;
6011
6012
return _bz_VecExpr<T_expr>(T_expr(d1,
6013
_bz_VecExprConstant<long double>(d2),
6014
d3.beginFast()));
6015
}
6016
6017
// where(Range, long double, Range)
6018
6019
inline
6020
_bz_VecExpr<_bz_VecWhere<Range,
6021
_bz_VecExprConstant<long double>,
6022
Range > >
6023
where(Range d1,
6024
long double d2,
6025
Range d3)
6026
{
6027
typedef _bz_VecWhere<Range,
6028
_bz_VecExprConstant<long double>,
6029
Range > T_expr;
6030
6031
return _bz_VecExpr<T_expr>(T_expr(d1,
6032
_bz_VecExprConstant<long double>(d2),
6033
d3));
6034
}
6035
6036
// where(Range, long double, TinyVector<P_numtype3, N_length3>)
6037
template<class P_numtype3, int N_length3>
6038
inline
6039
_bz_VecExpr<_bz_VecWhere<Range,
6040
_bz_VecExprConstant<long double>,
6041
TinyVectorIterConst<P_numtype3, N_length3> > >
6042
where(Range d1,
6043
long double d2,
6044
const TinyVector<P_numtype3, N_length3>& d3)
6045
{
6046
typedef _bz_VecWhere<Range,
6047
_bz_VecExprConstant<long double>,
6048
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
6049
6050
return _bz_VecExpr<T_expr>(T_expr(d1,
6051
_bz_VecExprConstant<long double>(d2),
6052
d3.beginFast()));
6053
}
6054
6055
// where(Range, long double, long double)
6056
6057
inline
6058
_bz_VecExpr<_bz_VecWhere<Range,
6059
_bz_VecExprConstant<long double>,
6060
_bz_VecExprConstant<long double> > >
6061
where(Range d1,
6062
long double d2,
6063
long double d3)
6064
{
6065
typedef _bz_VecWhere<Range,
6066
_bz_VecExprConstant<long double>,
6067
_bz_VecExprConstant<long double> > T_expr;
6068
6069
return _bz_VecExpr<T_expr>(T_expr(d1,
6070
_bz_VecExprConstant<long double>(d2),
6071
_bz_VecExprConstant<long double>(d3)));
6072
}
6073
6074
// where(Range, complex<T2>, Vector<P_numtype3>)
6075
#ifdef BZ_HAVE_COMPLEX
6076
template<class T2, class P_numtype3>
6077
inline
6078
_bz_VecExpr<_bz_VecWhere<Range,
6079
_bz_VecExprConstant<complex<T2> > ,
6080
VectorIterConst<P_numtype3> > >
6081
where(Range d1,
6082
complex<T2> d2,
6083
const Vector<P_numtype3>& d3)
6084
{
6085
typedef _bz_VecWhere<Range,
6086
_bz_VecExprConstant<complex<T2> > ,
6087
VectorIterConst<P_numtype3> > T_expr;
6088
6089
return _bz_VecExpr<T_expr>(T_expr(d1,
6090
_bz_VecExprConstant<complex<T2> > (d2),
6091
d3.beginFast()));
6092
}
6093
#endif // BZ_HAVE_COMPLEX
6094
6095
// where(Range, complex<T2>, _bz_VecExpr<P_expr3>)
6096
#ifdef BZ_HAVE_COMPLEX
6097
template<class T2, class P_expr3>
6098
inline
6099
_bz_VecExpr<_bz_VecWhere<Range,
6100
_bz_VecExprConstant<complex<T2> > ,
6101
_bz_VecExpr<P_expr3> > >
6102
where(Range d1,
6103
complex<T2> d2,
6104
_bz_VecExpr<P_expr3> d3)
6105
{
6106
typedef _bz_VecWhere<Range,
6107
_bz_VecExprConstant<complex<T2> > ,
6108
_bz_VecExpr<P_expr3> > T_expr;
6109
6110
return _bz_VecExpr<T_expr>(T_expr(d1,
6111
_bz_VecExprConstant<complex<T2> > (d2),
6112
d3));
6113
}
6114
#endif // BZ_HAVE_COMPLEX
6115
6116
// where(Range, complex<T2>, VectorPick<P_numtype3>)
6117
#ifdef BZ_HAVE_COMPLEX
6118
template<class T2, class P_numtype3>
6119
inline
6120
_bz_VecExpr<_bz_VecWhere<Range,
6121
_bz_VecExprConstant<complex<T2> > ,
6122
VectorPickIterConst<P_numtype3> > >
6123
where(Range d1,
6124
complex<T2> d2,
6125
const VectorPick<P_numtype3>& d3)
6126
{
6127
typedef _bz_VecWhere<Range,
6128
_bz_VecExprConstant<complex<T2> > ,
6129
VectorPickIterConst<P_numtype3> > T_expr;
6130
6131
return _bz_VecExpr<T_expr>(T_expr(d1,
6132
_bz_VecExprConstant<complex<T2> > (d2),
6133
d3.beginFast()));
6134
}
6135
#endif // BZ_HAVE_COMPLEX
6136
6137
// where(Range, complex<T2>, Range)
6138
#ifdef BZ_HAVE_COMPLEX
6139
template<class T2>
6140
inline
6141
_bz_VecExpr<_bz_VecWhere<Range,
6142
_bz_VecExprConstant<complex<T2> > ,
6143
Range > >
6144
where(Range d1,
6145
complex<T2> d2,
6146
Range d3)
6147
{
6148
typedef _bz_VecWhere<Range,
6149
_bz_VecExprConstant<complex<T2> > ,
6150
Range > T_expr;
6151
6152
return _bz_VecExpr<T_expr>(T_expr(d1,
6153
_bz_VecExprConstant<complex<T2> > (d2),
6154
d3));
6155
}
6156
#endif // BZ_HAVE_COMPLEX
6157
6158
// where(Range, complex<T2>, TinyVector<P_numtype3, N_length3>)
6159
#ifdef BZ_HAVE_COMPLEX
6160
template<class T2, class P_numtype3, int N_length3>
6161
inline
6162
_bz_VecExpr<_bz_VecWhere<Range,
6163
_bz_VecExprConstant<complex<T2> > ,
6164
TinyVectorIterConst<P_numtype3, N_length3> > >
6165
where(Range d1,
6166
complex<T2> d2,
6167
const TinyVector<P_numtype3, N_length3>& d3)
6168
{
6169
typedef _bz_VecWhere<Range,
6170
_bz_VecExprConstant<complex<T2> > ,
6171
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
6172
6173
return _bz_VecExpr<T_expr>(T_expr(d1,
6174
_bz_VecExprConstant<complex<T2> > (d2),
6175
d3.beginFast()));
6176
}
6177
#endif // BZ_HAVE_COMPLEX
6178
6179
// where(Range, complex<T2>, complex<T3>)
6180
#ifdef BZ_HAVE_COMPLEX
6181
template<class T2, class T3>
6182
inline
6183
_bz_VecExpr<_bz_VecWhere<Range,
6184
_bz_VecExprConstant<complex<T2> > ,
6185
_bz_VecExprConstant<complex<T3> > > >
6186
where(Range d1,
6187
complex<T2> d2,
6188
complex<T3> d3)
6189
{
6190
typedef _bz_VecWhere<Range,
6191
_bz_VecExprConstant<complex<T2> > ,
6192
_bz_VecExprConstant<complex<T3> > > T_expr;
6193
6194
return _bz_VecExpr<T_expr>(T_expr(d1,
6195
_bz_VecExprConstant<complex<T2> > (d2),
6196
_bz_VecExprConstant<complex<T3> > (d3)));
6197
}
6198
#endif // BZ_HAVE_COMPLEX
6199
6200
// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, Vector<P_numtype3>)
6201
template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3>
6202
inline
6203
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6204
VectorIterConst<P_numtype2>,
6205
VectorIterConst<P_numtype3> > >
6206
where(const TinyVector<P_numtype1, N_length1>& d1,
6207
const Vector<P_numtype2>& d2,
6208
const Vector<P_numtype3>& d3)
6209
{
6210
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6211
VectorIterConst<P_numtype2>,
6212
VectorIterConst<P_numtype3> > T_expr;
6213
6214
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6215
d2.beginFast(),
6216
d3.beginFast()));
6217
}
6218
6219
// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, _bz_VecExpr<P_expr3>)
6220
template<class P_numtype1, int N_length1, class P_numtype2, class P_expr3>
6221
inline
6222
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6223
VectorIterConst<P_numtype2>,
6224
_bz_VecExpr<P_expr3> > >
6225
where(const TinyVector<P_numtype1, N_length1>& d1,
6226
const Vector<P_numtype2>& d2,
6227
_bz_VecExpr<P_expr3> d3)
6228
{
6229
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6230
VectorIterConst<P_numtype2>,
6231
_bz_VecExpr<P_expr3> > T_expr;
6232
6233
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6234
d2.beginFast(),
6235
d3));
6236
}
6237
6238
// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, VectorPick<P_numtype3>)
6239
template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3>
6240
inline
6241
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6242
VectorIterConst<P_numtype2>,
6243
VectorPickIterConst<P_numtype3> > >
6244
where(const TinyVector<P_numtype1, N_length1>& d1,
6245
const Vector<P_numtype2>& d2,
6246
const VectorPick<P_numtype3>& d3)
6247
{
6248
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6249
VectorIterConst<P_numtype2>,
6250
VectorPickIterConst<P_numtype3> > T_expr;
6251
6252
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6253
d2.beginFast(),
6254
d3.beginFast()));
6255
}
6256
6257
// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, Range)
6258
template<class P_numtype1, int N_length1, class P_numtype2>
6259
inline
6260
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6261
VectorIterConst<P_numtype2>,
6262
Range > >
6263
where(const TinyVector<P_numtype1, N_length1>& d1,
6264
const Vector<P_numtype2>& d2,
6265
Range d3)
6266
{
6267
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6268
VectorIterConst<P_numtype2>,
6269
Range > T_expr;
6270
6271
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6272
d2.beginFast(),
6273
d3));
6274
}
6275
6276
// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, TinyVector<P_numtype3, N_length3>)
6277
template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3, int N_length3>
6278
inline
6279
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6280
VectorIterConst<P_numtype2>,
6281
TinyVectorIterConst<P_numtype3, N_length3> > >
6282
where(const TinyVector<P_numtype1, N_length1>& d1,
6283
const Vector<P_numtype2>& d2,
6284
const TinyVector<P_numtype3, N_length3>& d3)
6285
{
6286
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6287
VectorIterConst<P_numtype2>,
6288
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
6289
6290
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6291
d2.beginFast(),
6292
d3.beginFast()));
6293
}
6294
6295
// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, int)
6296
template<class P_numtype1, int N_length1, class P_numtype2>
6297
inline
6298
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6299
VectorIterConst<P_numtype2>,
6300
_bz_VecExprConstant<int> > >
6301
where(const TinyVector<P_numtype1, N_length1>& d1,
6302
const Vector<P_numtype2>& d2,
6303
int d3)
6304
{
6305
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6306
VectorIterConst<P_numtype2>,
6307
_bz_VecExprConstant<int> > T_expr;
6308
6309
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6310
d2.beginFast(),
6311
_bz_VecExprConstant<int>(d3)));
6312
}
6313
6314
// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, float)
6315
template<class P_numtype1, int N_length1, class P_numtype2>
6316
inline
6317
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6318
VectorIterConst<P_numtype2>,
6319
_bz_VecExprConstant<float> > >
6320
where(const TinyVector<P_numtype1, N_length1>& d1,
6321
const Vector<P_numtype2>& d2,
6322
float d3)
6323
{
6324
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6325
VectorIterConst<P_numtype2>,
6326
_bz_VecExprConstant<float> > T_expr;
6327
6328
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6329
d2.beginFast(),
6330
_bz_VecExprConstant<float>(d3)));
6331
}
6332
6333
// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, double)
6334
template<class P_numtype1, int N_length1, class P_numtype2>
6335
inline
6336
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6337
VectorIterConst<P_numtype2>,
6338
_bz_VecExprConstant<double> > >
6339
where(const TinyVector<P_numtype1, N_length1>& d1,
6340
const Vector<P_numtype2>& d2,
6341
double d3)
6342
{
6343
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6344
VectorIterConst<P_numtype2>,
6345
_bz_VecExprConstant<double> > T_expr;
6346
6347
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6348
d2.beginFast(),
6349
_bz_VecExprConstant<double>(d3)));
6350
}
6351
6352
// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, long double)
6353
template<class P_numtype1, int N_length1, class P_numtype2>
6354
inline
6355
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6356
VectorIterConst<P_numtype2>,
6357
_bz_VecExprConstant<long double> > >
6358
where(const TinyVector<P_numtype1, N_length1>& d1,
6359
const Vector<P_numtype2>& d2,
6360
long double d3)
6361
{
6362
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6363
VectorIterConst<P_numtype2>,
6364
_bz_VecExprConstant<long double> > T_expr;
6365
6366
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6367
d2.beginFast(),
6368
_bz_VecExprConstant<long double>(d3)));
6369
}
6370
6371
// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, complex<T3>)
6372
#ifdef BZ_HAVE_COMPLEX
6373
template<class P_numtype1, int N_length1, class P_numtype2, class T3>
6374
inline
6375
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6376
VectorIterConst<P_numtype2>,
6377
_bz_VecExprConstant<complex<T3> > > >
6378
where(const TinyVector<P_numtype1, N_length1>& d1,
6379
const Vector<P_numtype2>& d2,
6380
complex<T3> d3)
6381
{
6382
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6383
VectorIterConst<P_numtype2>,
6384
_bz_VecExprConstant<complex<T3> > > T_expr;
6385
6386
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6387
d2.beginFast(),
6388
_bz_VecExprConstant<complex<T3> > (d3)));
6389
}
6390
#endif // BZ_HAVE_COMPLEX
6391
6392
// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, Vector<P_numtype3>)
6393
template<class P_numtype1, int N_length1, class P_expr2, class P_numtype3>
6394
inline
6395
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6396
_bz_VecExpr<P_expr2>,
6397
VectorIterConst<P_numtype3> > >
6398
where(const TinyVector<P_numtype1, N_length1>& d1,
6399
_bz_VecExpr<P_expr2> d2,
6400
const Vector<P_numtype3>& d3)
6401
{
6402
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6403
_bz_VecExpr<P_expr2>,
6404
VectorIterConst<P_numtype3> > T_expr;
6405
6406
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6407
d2,
6408
d3.beginFast()));
6409
}
6410
6411
// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, _bz_VecExpr<P_expr3>)
6412
template<class P_numtype1, int N_length1, class P_expr2, class P_expr3>
6413
inline
6414
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6415
_bz_VecExpr<P_expr2>,
6416
_bz_VecExpr<P_expr3> > >
6417
where(const TinyVector<P_numtype1, N_length1>& d1,
6418
_bz_VecExpr<P_expr2> d2,
6419
_bz_VecExpr<P_expr3> d3)
6420
{
6421
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6422
_bz_VecExpr<P_expr2>,
6423
_bz_VecExpr<P_expr3> > T_expr;
6424
6425
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6426
d2,
6427
d3));
6428
}
6429
6430
// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, VectorPick<P_numtype3>)
6431
template<class P_numtype1, int N_length1, class P_expr2, class P_numtype3>
6432
inline
6433
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6434
_bz_VecExpr<P_expr2>,
6435
VectorPickIterConst<P_numtype3> > >
6436
where(const TinyVector<P_numtype1, N_length1>& d1,
6437
_bz_VecExpr<P_expr2> d2,
6438
const VectorPick<P_numtype3>& d3)
6439
{
6440
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6441
_bz_VecExpr<P_expr2>,
6442
VectorPickIterConst<P_numtype3> > T_expr;
6443
6444
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6445
d2,
6446
d3.beginFast()));
6447
}
6448
6449
// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, Range)
6450
template<class P_numtype1, int N_length1, class P_expr2>
6451
inline
6452
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6453
_bz_VecExpr<P_expr2>,
6454
Range > >
6455
where(const TinyVector<P_numtype1, N_length1>& d1,
6456
_bz_VecExpr<P_expr2> d2,
6457
Range d3)
6458
{
6459
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6460
_bz_VecExpr<P_expr2>,
6461
Range > T_expr;
6462
6463
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6464
d2,
6465
d3));
6466
}
6467
6468
// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, TinyVector<P_numtype3, N_length3>)
6469
template<class P_numtype1, int N_length1, class P_expr2, class P_numtype3, int N_length3>
6470
inline
6471
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6472
_bz_VecExpr<P_expr2>,
6473
TinyVectorIterConst<P_numtype3, N_length3> > >
6474
where(const TinyVector<P_numtype1, N_length1>& d1,
6475
_bz_VecExpr<P_expr2> d2,
6476
const TinyVector<P_numtype3, N_length3>& d3)
6477
{
6478
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6479
_bz_VecExpr<P_expr2>,
6480
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
6481
6482
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6483
d2,
6484
d3.beginFast()));
6485
}
6486
6487
// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, int)
6488
template<class P_numtype1, int N_length1, class P_expr2>
6489
inline
6490
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6491
_bz_VecExpr<P_expr2>,
6492
_bz_VecExprConstant<int> > >
6493
where(const TinyVector<P_numtype1, N_length1>& d1,
6494
_bz_VecExpr<P_expr2> d2,
6495
int d3)
6496
{
6497
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6498
_bz_VecExpr<P_expr2>,
6499
_bz_VecExprConstant<int> > T_expr;
6500
6501
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6502
d2,
6503
_bz_VecExprConstant<int>(d3)));
6504
}
6505
6506
// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, float)
6507
template<class P_numtype1, int N_length1, class P_expr2>
6508
inline
6509
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6510
_bz_VecExpr<P_expr2>,
6511
_bz_VecExprConstant<float> > >
6512
where(const TinyVector<P_numtype1, N_length1>& d1,
6513
_bz_VecExpr<P_expr2> d2,
6514
float d3)
6515
{
6516
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6517
_bz_VecExpr<P_expr2>,
6518
_bz_VecExprConstant<float> > T_expr;
6519
6520
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6521
d2,
6522
_bz_VecExprConstant<float>(d3)));
6523
}
6524
6525
// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, double)
6526
template<class P_numtype1, int N_length1, class P_expr2>
6527
inline
6528
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6529
_bz_VecExpr<P_expr2>,
6530
_bz_VecExprConstant<double> > >
6531
where(const TinyVector<P_numtype1, N_length1>& d1,
6532
_bz_VecExpr<P_expr2> d2,
6533
double d3)
6534
{
6535
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6536
_bz_VecExpr<P_expr2>,
6537
_bz_VecExprConstant<double> > T_expr;
6538
6539
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6540
d2,
6541
_bz_VecExprConstant<double>(d3)));
6542
}
6543
6544
// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, long double)
6545
template<class P_numtype1, int N_length1, class P_expr2>
6546
inline
6547
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6548
_bz_VecExpr<P_expr2>,
6549
_bz_VecExprConstant<long double> > >
6550
where(const TinyVector<P_numtype1, N_length1>& d1,
6551
_bz_VecExpr<P_expr2> d2,
6552
long double d3)
6553
{
6554
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6555
_bz_VecExpr<P_expr2>,
6556
_bz_VecExprConstant<long double> > T_expr;
6557
6558
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6559
d2,
6560
_bz_VecExprConstant<long double>(d3)));
6561
}
6562
6563
// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, complex<T3>)
6564
#ifdef BZ_HAVE_COMPLEX
6565
template<class P_numtype1, int N_length1, class P_expr2, class T3>
6566
inline
6567
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6568
_bz_VecExpr<P_expr2>,
6569
_bz_VecExprConstant<complex<T3> > > >
6570
where(const TinyVector<P_numtype1, N_length1>& d1,
6571
_bz_VecExpr<P_expr2> d2,
6572
complex<T3> d3)
6573
{
6574
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6575
_bz_VecExpr<P_expr2>,
6576
_bz_VecExprConstant<complex<T3> > > T_expr;
6577
6578
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6579
d2,
6580
_bz_VecExprConstant<complex<T3> > (d3)));
6581
}
6582
#endif // BZ_HAVE_COMPLEX
6583
6584
// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, Vector<P_numtype3>)
6585
template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3>
6586
inline
6587
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6588
VectorPickIterConst<P_numtype2>,
6589
VectorIterConst<P_numtype3> > >
6590
where(const TinyVector<P_numtype1, N_length1>& d1,
6591
const VectorPick<P_numtype2>& d2,
6592
const Vector<P_numtype3>& d3)
6593
{
6594
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6595
VectorPickIterConst<P_numtype2>,
6596
VectorIterConst<P_numtype3> > T_expr;
6597
6598
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6599
d2.beginFast(),
6600
d3.beginFast()));
6601
}
6602
6603
// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, _bz_VecExpr<P_expr3>)
6604
template<class P_numtype1, int N_length1, class P_numtype2, class P_expr3>
6605
inline
6606
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6607
VectorPickIterConst<P_numtype2>,
6608
_bz_VecExpr<P_expr3> > >
6609
where(const TinyVector<P_numtype1, N_length1>& d1,
6610
const VectorPick<P_numtype2>& d2,
6611
_bz_VecExpr<P_expr3> d3)
6612
{
6613
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6614
VectorPickIterConst<P_numtype2>,
6615
_bz_VecExpr<P_expr3> > T_expr;
6616
6617
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6618
d2.beginFast(),
6619
d3));
6620
}
6621
6622
// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, VectorPick<P_numtype3>)
6623
template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3>
6624
inline
6625
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6626
VectorPickIterConst<P_numtype2>,
6627
VectorPickIterConst<P_numtype3> > >
6628
where(const TinyVector<P_numtype1, N_length1>& d1,
6629
const VectorPick<P_numtype2>& d2,
6630
const VectorPick<P_numtype3>& d3)
6631
{
6632
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6633
VectorPickIterConst<P_numtype2>,
6634
VectorPickIterConst<P_numtype3> > T_expr;
6635
6636
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6637
d2.beginFast(),
6638
d3.beginFast()));
6639
}
6640
6641
// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, Range)
6642
template<class P_numtype1, int N_length1, class P_numtype2>
6643
inline
6644
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6645
VectorPickIterConst<P_numtype2>,
6646
Range > >
6647
where(const TinyVector<P_numtype1, N_length1>& d1,
6648
const VectorPick<P_numtype2>& d2,
6649
Range d3)
6650
{
6651
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6652
VectorPickIterConst<P_numtype2>,
6653
Range > T_expr;
6654
6655
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6656
d2.beginFast(),
6657
d3));
6658
}
6659
6660
// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, TinyVector<P_numtype3, N_length3>)
6661
template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3, int N_length3>
6662
inline
6663
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6664
VectorPickIterConst<P_numtype2>,
6665
TinyVectorIterConst<P_numtype3, N_length3> > >
6666
where(const TinyVector<P_numtype1, N_length1>& d1,
6667
const VectorPick<P_numtype2>& d2,
6668
const TinyVector<P_numtype3, N_length3>& d3)
6669
{
6670
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6671
VectorPickIterConst<P_numtype2>,
6672
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
6673
6674
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6675
d2.beginFast(),
6676
d3.beginFast()));
6677
}
6678
6679
// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, int)
6680
template<class P_numtype1, int N_length1, class P_numtype2>
6681
inline
6682
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6683
VectorPickIterConst<P_numtype2>,
6684
_bz_VecExprConstant<int> > >
6685
where(const TinyVector<P_numtype1, N_length1>& d1,
6686
const VectorPick<P_numtype2>& d2,
6687
int d3)
6688
{
6689
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6690
VectorPickIterConst<P_numtype2>,
6691
_bz_VecExprConstant<int> > T_expr;
6692
6693
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6694
d2.beginFast(),
6695
_bz_VecExprConstant<int>(d3)));
6696
}
6697
6698
// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, float)
6699
template<class P_numtype1, int N_length1, class P_numtype2>
6700
inline
6701
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6702
VectorPickIterConst<P_numtype2>,
6703
_bz_VecExprConstant<float> > >
6704
where(const TinyVector<P_numtype1, N_length1>& d1,
6705
const VectorPick<P_numtype2>& d2,
6706
float d3)
6707
{
6708
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6709
VectorPickIterConst<P_numtype2>,
6710
_bz_VecExprConstant<float> > T_expr;
6711
6712
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6713
d2.beginFast(),
6714
_bz_VecExprConstant<float>(d3)));
6715
}
6716
6717
// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, double)
6718
template<class P_numtype1, int N_length1, class P_numtype2>
6719
inline
6720
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6721
VectorPickIterConst<P_numtype2>,
6722
_bz_VecExprConstant<double> > >
6723
where(const TinyVector<P_numtype1, N_length1>& d1,
6724
const VectorPick<P_numtype2>& d2,
6725
double d3)
6726
{
6727
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6728
VectorPickIterConst<P_numtype2>,
6729
_bz_VecExprConstant<double> > T_expr;
6730
6731
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6732
d2.beginFast(),
6733
_bz_VecExprConstant<double>(d3)));
6734
}
6735
6736
// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, long double)
6737
template<class P_numtype1, int N_length1, class P_numtype2>
6738
inline
6739
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6740
VectorPickIterConst<P_numtype2>,
6741
_bz_VecExprConstant<long double> > >
6742
where(const TinyVector<P_numtype1, N_length1>& d1,
6743
const VectorPick<P_numtype2>& d2,
6744
long double d3)
6745
{
6746
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6747
VectorPickIterConst<P_numtype2>,
6748
_bz_VecExprConstant<long double> > T_expr;
6749
6750
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6751
d2.beginFast(),
6752
_bz_VecExprConstant<long double>(d3)));
6753
}
6754
6755
// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, complex<T3>)
6756
#ifdef BZ_HAVE_COMPLEX
6757
template<class P_numtype1, int N_length1, class P_numtype2, class T3>
6758
inline
6759
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6760
VectorPickIterConst<P_numtype2>,
6761
_bz_VecExprConstant<complex<T3> > > >
6762
where(const TinyVector<P_numtype1, N_length1>& d1,
6763
const VectorPick<P_numtype2>& d2,
6764
complex<T3> d3)
6765
{
6766
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6767
VectorPickIterConst<P_numtype2>,
6768
_bz_VecExprConstant<complex<T3> > > T_expr;
6769
6770
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6771
d2.beginFast(),
6772
_bz_VecExprConstant<complex<T3> > (d3)));
6773
}
6774
#endif // BZ_HAVE_COMPLEX
6775
6776
// where(TinyVector<P_numtype1, N_length1>, Range, Vector<P_numtype3>)
6777
template<class P_numtype1, int N_length1, class P_numtype3>
6778
inline
6779
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6780
Range,
6781
VectorIterConst<P_numtype3> > >
6782
where(const TinyVector<P_numtype1, N_length1>& d1,
6783
Range d2,
6784
const Vector<P_numtype3>& d3)
6785
{
6786
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6787
Range,
6788
VectorIterConst<P_numtype3> > T_expr;
6789
6790
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6791
d2,
6792
d3.beginFast()));
6793
}
6794
6795
// where(TinyVector<P_numtype1, N_length1>, Range, _bz_VecExpr<P_expr3>)
6796
template<class P_numtype1, int N_length1, class P_expr3>
6797
inline
6798
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6799
Range,
6800
_bz_VecExpr<P_expr3> > >
6801
where(const TinyVector<P_numtype1, N_length1>& d1,
6802
Range d2,
6803
_bz_VecExpr<P_expr3> d3)
6804
{
6805
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6806
Range,
6807
_bz_VecExpr<P_expr3> > T_expr;
6808
6809
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6810
d2,
6811
d3));
6812
}
6813
6814
// where(TinyVector<P_numtype1, N_length1>, Range, VectorPick<P_numtype3>)
6815
template<class P_numtype1, int N_length1, class P_numtype3>
6816
inline
6817
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6818
Range,
6819
VectorPickIterConst<P_numtype3> > >
6820
where(const TinyVector<P_numtype1, N_length1>& d1,
6821
Range d2,
6822
const VectorPick<P_numtype3>& d3)
6823
{
6824
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6825
Range,
6826
VectorPickIterConst<P_numtype3> > T_expr;
6827
6828
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6829
d2,
6830
d3.beginFast()));
6831
}
6832
6833
// where(TinyVector<P_numtype1, N_length1>, Range, Range)
6834
template<class P_numtype1, int N_length1>
6835
inline
6836
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6837
Range,
6838
Range > >
6839
where(const TinyVector<P_numtype1, N_length1>& d1,
6840
Range d2,
6841
Range d3)
6842
{
6843
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6844
Range,
6845
Range > T_expr;
6846
6847
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6848
d2,
6849
d3));
6850
}
6851
6852
// where(TinyVector<P_numtype1, N_length1>, Range, TinyVector<P_numtype3, N_length3>)
6853
template<class P_numtype1, int N_length1, class P_numtype3, int N_length3>
6854
inline
6855
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6856
Range,
6857
TinyVectorIterConst<P_numtype3, N_length3> > >
6858
where(const TinyVector<P_numtype1, N_length1>& d1,
6859
Range d2,
6860
const TinyVector<P_numtype3, N_length3>& d3)
6861
{
6862
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6863
Range,
6864
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
6865
6866
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6867
d2,
6868
d3.beginFast()));
6869
}
6870
6871
// where(TinyVector<P_numtype1, N_length1>, Range, int)
6872
template<class P_numtype1, int N_length1>
6873
inline
6874
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6875
Range,
6876
_bz_VecExprConstant<int> > >
6877
where(const TinyVector<P_numtype1, N_length1>& d1,
6878
Range d2,
6879
int d3)
6880
{
6881
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6882
Range,
6883
_bz_VecExprConstant<int> > T_expr;
6884
6885
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6886
d2,
6887
_bz_VecExprConstant<int>(d3)));
6888
}
6889
6890
// where(TinyVector<P_numtype1, N_length1>, Range, float)
6891
template<class P_numtype1, int N_length1>
6892
inline
6893
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6894
Range,
6895
_bz_VecExprConstant<float> > >
6896
where(const TinyVector<P_numtype1, N_length1>& d1,
6897
Range d2,
6898
float d3)
6899
{
6900
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6901
Range,
6902
_bz_VecExprConstant<float> > T_expr;
6903
6904
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6905
d2,
6906
_bz_VecExprConstant<float>(d3)));
6907
}
6908
6909
// where(TinyVector<P_numtype1, N_length1>, Range, double)
6910
template<class P_numtype1, int N_length1>
6911
inline
6912
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6913
Range,
6914
_bz_VecExprConstant<double> > >
6915
where(const TinyVector<P_numtype1, N_length1>& d1,
6916
Range d2,
6917
double d3)
6918
{
6919
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6920
Range,
6921
_bz_VecExprConstant<double> > T_expr;
6922
6923
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6924
d2,
6925
_bz_VecExprConstant<double>(d3)));
6926
}
6927
6928
// where(TinyVector<P_numtype1, N_length1>, Range, long double)
6929
template<class P_numtype1, int N_length1>
6930
inline
6931
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6932
Range,
6933
_bz_VecExprConstant<long double> > >
6934
where(const TinyVector<P_numtype1, N_length1>& d1,
6935
Range d2,
6936
long double d3)
6937
{
6938
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6939
Range,
6940
_bz_VecExprConstant<long double> > T_expr;
6941
6942
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6943
d2,
6944
_bz_VecExprConstant<long double>(d3)));
6945
}
6946
6947
// where(TinyVector<P_numtype1, N_length1>, Range, complex<T3>)
6948
#ifdef BZ_HAVE_COMPLEX
6949
template<class P_numtype1, int N_length1, class T3>
6950
inline
6951
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6952
Range,
6953
_bz_VecExprConstant<complex<T3> > > >
6954
where(const TinyVector<P_numtype1, N_length1>& d1,
6955
Range d2,
6956
complex<T3> d3)
6957
{
6958
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6959
Range,
6960
_bz_VecExprConstant<complex<T3> > > T_expr;
6961
6962
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6963
d2,
6964
_bz_VecExprConstant<complex<T3> > (d3)));
6965
}
6966
#endif // BZ_HAVE_COMPLEX
6967
6968
// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, Vector<P_numtype3>)
6969
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2, class P_numtype3>
6970
inline
6971
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6972
TinyVectorIterConst<P_numtype2, N_length2>,
6973
VectorIterConst<P_numtype3> > >
6974
where(const TinyVector<P_numtype1, N_length1>& d1,
6975
const TinyVector<P_numtype2, N_length2>& d2,
6976
const Vector<P_numtype3>& d3)
6977
{
6978
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6979
TinyVectorIterConst<P_numtype2, N_length2>,
6980
VectorIterConst<P_numtype3> > T_expr;
6981
6982
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
6983
d2.beginFast(),
6984
d3.beginFast()));
6985
}
6986
6987
// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, _bz_VecExpr<P_expr3>)
6988
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2, class P_expr3>
6989
inline
6990
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6991
TinyVectorIterConst<P_numtype2, N_length2>,
6992
_bz_VecExpr<P_expr3> > >
6993
where(const TinyVector<P_numtype1, N_length1>& d1,
6994
const TinyVector<P_numtype2, N_length2>& d2,
6995
_bz_VecExpr<P_expr3> d3)
6996
{
6997
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
6998
TinyVectorIterConst<P_numtype2, N_length2>,
6999
_bz_VecExpr<P_expr3> > T_expr;
7000
7001
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7002
d2.beginFast(),
7003
d3));
7004
}
7005
7006
// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, VectorPick<P_numtype3>)
7007
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2, class P_numtype3>
7008
inline
7009
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7010
TinyVectorIterConst<P_numtype2, N_length2>,
7011
VectorPickIterConst<P_numtype3> > >
7012
where(const TinyVector<P_numtype1, N_length1>& d1,
7013
const TinyVector<P_numtype2, N_length2>& d2,
7014
const VectorPick<P_numtype3>& d3)
7015
{
7016
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7017
TinyVectorIterConst<P_numtype2, N_length2>,
7018
VectorPickIterConst<P_numtype3> > T_expr;
7019
7020
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7021
d2.beginFast(),
7022
d3.beginFast()));
7023
}
7024
7025
// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, Range)
7026
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
7027
inline
7028
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7029
TinyVectorIterConst<P_numtype2, N_length2>,
7030
Range > >
7031
where(const TinyVector<P_numtype1, N_length1>& d1,
7032
const TinyVector<P_numtype2, N_length2>& d2,
7033
Range d3)
7034
{
7035
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7036
TinyVectorIterConst<P_numtype2, N_length2>,
7037
Range > T_expr;
7038
7039
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7040
d2.beginFast(),
7041
d3));
7042
}
7043
7044
// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, TinyVector<P_numtype3, N_length3>)
7045
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2, class P_numtype3, int N_length3>
7046
inline
7047
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7048
TinyVectorIterConst<P_numtype2, N_length2>,
7049
TinyVectorIterConst<P_numtype3, N_length3> > >
7050
where(const TinyVector<P_numtype1, N_length1>& d1,
7051
const TinyVector<P_numtype2, N_length2>& d2,
7052
const TinyVector<P_numtype3, N_length3>& d3)
7053
{
7054
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7055
TinyVectorIterConst<P_numtype2, N_length2>,
7056
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
7057
7058
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7059
d2.beginFast(),
7060
d3.beginFast()));
7061
}
7062
7063
// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, int)
7064
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
7065
inline
7066
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7067
TinyVectorIterConst<P_numtype2, N_length2>,
7068
_bz_VecExprConstant<int> > >
7069
where(const TinyVector<P_numtype1, N_length1>& d1,
7070
const TinyVector<P_numtype2, N_length2>& d2,
7071
int d3)
7072
{
7073
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7074
TinyVectorIterConst<P_numtype2, N_length2>,
7075
_bz_VecExprConstant<int> > T_expr;
7076
7077
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7078
d2.beginFast(),
7079
_bz_VecExprConstant<int>(d3)));
7080
}
7081
7082
// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, float)
7083
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
7084
inline
7085
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7086
TinyVectorIterConst<P_numtype2, N_length2>,
7087
_bz_VecExprConstant<float> > >
7088
where(const TinyVector<P_numtype1, N_length1>& d1,
7089
const TinyVector<P_numtype2, N_length2>& d2,
7090
float d3)
7091
{
7092
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7093
TinyVectorIterConst<P_numtype2, N_length2>,
7094
_bz_VecExprConstant<float> > T_expr;
7095
7096
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7097
d2.beginFast(),
7098
_bz_VecExprConstant<float>(d3)));
7099
}
7100
7101
// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, double)
7102
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
7103
inline
7104
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7105
TinyVectorIterConst<P_numtype2, N_length2>,
7106
_bz_VecExprConstant<double> > >
7107
where(const TinyVector<P_numtype1, N_length1>& d1,
7108
const TinyVector<P_numtype2, N_length2>& d2,
7109
double d3)
7110
{
7111
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7112
TinyVectorIterConst<P_numtype2, N_length2>,
7113
_bz_VecExprConstant<double> > T_expr;
7114
7115
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7116
d2.beginFast(),
7117
_bz_VecExprConstant<double>(d3)));
7118
}
7119
7120
// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, long double)
7121
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
7122
inline
7123
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7124
TinyVectorIterConst<P_numtype2, N_length2>,
7125
_bz_VecExprConstant<long double> > >
7126
where(const TinyVector<P_numtype1, N_length1>& d1,
7127
const TinyVector<P_numtype2, N_length2>& d2,
7128
long double d3)
7129
{
7130
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7131
TinyVectorIterConst<P_numtype2, N_length2>,
7132
_bz_VecExprConstant<long double> > T_expr;
7133
7134
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7135
d2.beginFast(),
7136
_bz_VecExprConstant<long double>(d3)));
7137
}
7138
7139
// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, complex<T3>)
7140
#ifdef BZ_HAVE_COMPLEX
7141
template<class P_numtype1, int N_length1, class P_numtype2, int N_length2, class T3>
7142
inline
7143
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7144
TinyVectorIterConst<P_numtype2, N_length2>,
7145
_bz_VecExprConstant<complex<T3> > > >
7146
where(const TinyVector<P_numtype1, N_length1>& d1,
7147
const TinyVector<P_numtype2, N_length2>& d2,
7148
complex<T3> d3)
7149
{
7150
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7151
TinyVectorIterConst<P_numtype2, N_length2>,
7152
_bz_VecExprConstant<complex<T3> > > T_expr;
7153
7154
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7155
d2.beginFast(),
7156
_bz_VecExprConstant<complex<T3> > (d3)));
7157
}
7158
#endif // BZ_HAVE_COMPLEX
7159
7160
// where(TinyVector<P_numtype1, N_length1>, int, Vector<P_numtype3>)
7161
template<class P_numtype1, int N_length1, class P_numtype3>
7162
inline
7163
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7164
_bz_VecExprConstant<int>,
7165
VectorIterConst<P_numtype3> > >
7166
where(const TinyVector<P_numtype1, N_length1>& d1,
7167
int d2,
7168
const Vector<P_numtype3>& d3)
7169
{
7170
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7171
_bz_VecExprConstant<int>,
7172
VectorIterConst<P_numtype3> > T_expr;
7173
7174
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7175
_bz_VecExprConstant<int>(d2),
7176
d3.beginFast()));
7177
}
7178
7179
// where(TinyVector<P_numtype1, N_length1>, int, _bz_VecExpr<P_expr3>)
7180
template<class P_numtype1, int N_length1, class P_expr3>
7181
inline
7182
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7183
_bz_VecExprConstant<int>,
7184
_bz_VecExpr<P_expr3> > >
7185
where(const TinyVector<P_numtype1, N_length1>& d1,
7186
int d2,
7187
_bz_VecExpr<P_expr3> d3)
7188
{
7189
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7190
_bz_VecExprConstant<int>,
7191
_bz_VecExpr<P_expr3> > T_expr;
7192
7193
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7194
_bz_VecExprConstant<int>(d2),
7195
d3));
7196
}
7197
7198
// where(TinyVector<P_numtype1, N_length1>, int, VectorPick<P_numtype3>)
7199
template<class P_numtype1, int N_length1, class P_numtype3>
7200
inline
7201
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7202
_bz_VecExprConstant<int>,
7203
VectorPickIterConst<P_numtype3> > >
7204
where(const TinyVector<P_numtype1, N_length1>& d1,
7205
int d2,
7206
const VectorPick<P_numtype3>& d3)
7207
{
7208
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7209
_bz_VecExprConstant<int>,
7210
VectorPickIterConst<P_numtype3> > T_expr;
7211
7212
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7213
_bz_VecExprConstant<int>(d2),
7214
d3.beginFast()));
7215
}
7216
7217
// where(TinyVector<P_numtype1, N_length1>, int, Range)
7218
template<class P_numtype1, int N_length1>
7219
inline
7220
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7221
_bz_VecExprConstant<int>,
7222
Range > >
7223
where(const TinyVector<P_numtype1, N_length1>& d1,
7224
int d2,
7225
Range d3)
7226
{
7227
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7228
_bz_VecExprConstant<int>,
7229
Range > T_expr;
7230
7231
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7232
_bz_VecExprConstant<int>(d2),
7233
d3));
7234
}
7235
7236
// where(TinyVector<P_numtype1, N_length1>, int, TinyVector<P_numtype3, N_length3>)
7237
template<class P_numtype1, int N_length1, class P_numtype3, int N_length3>
7238
inline
7239
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7240
_bz_VecExprConstant<int>,
7241
TinyVectorIterConst<P_numtype3, N_length3> > >
7242
where(const TinyVector<P_numtype1, N_length1>& d1,
7243
int d2,
7244
const TinyVector<P_numtype3, N_length3>& d3)
7245
{
7246
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7247
_bz_VecExprConstant<int>,
7248
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
7249
7250
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7251
_bz_VecExprConstant<int>(d2),
7252
d3.beginFast()));
7253
}
7254
7255
// where(TinyVector<P_numtype1, N_length1>, int, int)
7256
template<class P_numtype1, int N_length1>
7257
inline
7258
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7259
_bz_VecExprConstant<int>,
7260
_bz_VecExprConstant<int> > >
7261
where(const TinyVector<P_numtype1, N_length1>& d1,
7262
int d2,
7263
int d3)
7264
{
7265
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7266
_bz_VecExprConstant<int>,
7267
_bz_VecExprConstant<int> > T_expr;
7268
7269
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7270
_bz_VecExprConstant<int>(d2),
7271
_bz_VecExprConstant<int>(d3)));
7272
}
7273
7274
// where(TinyVector<P_numtype1, N_length1>, float, Vector<P_numtype3>)
7275
template<class P_numtype1, int N_length1, class P_numtype3>
7276
inline
7277
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7278
_bz_VecExprConstant<float>,
7279
VectorIterConst<P_numtype3> > >
7280
where(const TinyVector<P_numtype1, N_length1>& d1,
7281
float d2,
7282
const Vector<P_numtype3>& d3)
7283
{
7284
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7285
_bz_VecExprConstant<float>,
7286
VectorIterConst<P_numtype3> > T_expr;
7287
7288
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7289
_bz_VecExprConstant<float>(d2),
7290
d3.beginFast()));
7291
}
7292
7293
// where(TinyVector<P_numtype1, N_length1>, float, _bz_VecExpr<P_expr3>)
7294
template<class P_numtype1, int N_length1, class P_expr3>
7295
inline
7296
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7297
_bz_VecExprConstant<float>,
7298
_bz_VecExpr<P_expr3> > >
7299
where(const TinyVector<P_numtype1, N_length1>& d1,
7300
float d2,
7301
_bz_VecExpr<P_expr3> d3)
7302
{
7303
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7304
_bz_VecExprConstant<float>,
7305
_bz_VecExpr<P_expr3> > T_expr;
7306
7307
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7308
_bz_VecExprConstant<float>(d2),
7309
d3));
7310
}
7311
7312
// where(TinyVector<P_numtype1, N_length1>, float, VectorPick<P_numtype3>)
7313
template<class P_numtype1, int N_length1, class P_numtype3>
7314
inline
7315
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7316
_bz_VecExprConstant<float>,
7317
VectorPickIterConst<P_numtype3> > >
7318
where(const TinyVector<P_numtype1, N_length1>& d1,
7319
float d2,
7320
const VectorPick<P_numtype3>& d3)
7321
{
7322
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7323
_bz_VecExprConstant<float>,
7324
VectorPickIterConst<P_numtype3> > T_expr;
7325
7326
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7327
_bz_VecExprConstant<float>(d2),
7328
d3.beginFast()));
7329
}
7330
7331
// where(TinyVector<P_numtype1, N_length1>, float, Range)
7332
template<class P_numtype1, int N_length1>
7333
inline
7334
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7335
_bz_VecExprConstant<float>,
7336
Range > >
7337
where(const TinyVector<P_numtype1, N_length1>& d1,
7338
float d2,
7339
Range d3)
7340
{
7341
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7342
_bz_VecExprConstant<float>,
7343
Range > T_expr;
7344
7345
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7346
_bz_VecExprConstant<float>(d2),
7347
d3));
7348
}
7349
7350
// where(TinyVector<P_numtype1, N_length1>, float, TinyVector<P_numtype3, N_length3>)
7351
template<class P_numtype1, int N_length1, class P_numtype3, int N_length3>
7352
inline
7353
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7354
_bz_VecExprConstant<float>,
7355
TinyVectorIterConst<P_numtype3, N_length3> > >
7356
where(const TinyVector<P_numtype1, N_length1>& d1,
7357
float d2,
7358
const TinyVector<P_numtype3, N_length3>& d3)
7359
{
7360
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7361
_bz_VecExprConstant<float>,
7362
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
7363
7364
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7365
_bz_VecExprConstant<float>(d2),
7366
d3.beginFast()));
7367
}
7368
7369
// where(TinyVector<P_numtype1, N_length1>, float, float)
7370
template<class P_numtype1, int N_length1>
7371
inline
7372
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7373
_bz_VecExprConstant<float>,
7374
_bz_VecExprConstant<float> > >
7375
where(const TinyVector<P_numtype1, N_length1>& d1,
7376
float d2,
7377
float d3)
7378
{
7379
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7380
_bz_VecExprConstant<float>,
7381
_bz_VecExprConstant<float> > T_expr;
7382
7383
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7384
_bz_VecExprConstant<float>(d2),
7385
_bz_VecExprConstant<float>(d3)));
7386
}
7387
7388
// where(TinyVector<P_numtype1, N_length1>, double, Vector<P_numtype3>)
7389
template<class P_numtype1, int N_length1, class P_numtype3>
7390
inline
7391
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7392
_bz_VecExprConstant<double>,
7393
VectorIterConst<P_numtype3> > >
7394
where(const TinyVector<P_numtype1, N_length1>& d1,
7395
double d2,
7396
const Vector<P_numtype3>& d3)
7397
{
7398
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7399
_bz_VecExprConstant<double>,
7400
VectorIterConst<P_numtype3> > T_expr;
7401
7402
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7403
_bz_VecExprConstant<double>(d2),
7404
d3.beginFast()));
7405
}
7406
7407
// where(TinyVector<P_numtype1, N_length1>, double, _bz_VecExpr<P_expr3>)
7408
template<class P_numtype1, int N_length1, class P_expr3>
7409
inline
7410
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7411
_bz_VecExprConstant<double>,
7412
_bz_VecExpr<P_expr3> > >
7413
where(const TinyVector<P_numtype1, N_length1>& d1,
7414
double d2,
7415
_bz_VecExpr<P_expr3> d3)
7416
{
7417
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7418
_bz_VecExprConstant<double>,
7419
_bz_VecExpr<P_expr3> > T_expr;
7420
7421
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7422
_bz_VecExprConstant<double>(d2),
7423
d3));
7424
}
7425
7426
// where(TinyVector<P_numtype1, N_length1>, double, VectorPick<P_numtype3>)
7427
template<class P_numtype1, int N_length1, class P_numtype3>
7428
inline
7429
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7430
_bz_VecExprConstant<double>,
7431
VectorPickIterConst<P_numtype3> > >
7432
where(const TinyVector<P_numtype1, N_length1>& d1,
7433
double d2,
7434
const VectorPick<P_numtype3>& d3)
7435
{
7436
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7437
_bz_VecExprConstant<double>,
7438
VectorPickIterConst<P_numtype3> > T_expr;
7439
7440
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7441
_bz_VecExprConstant<double>(d2),
7442
d3.beginFast()));
7443
}
7444
7445
// where(TinyVector<P_numtype1, N_length1>, double, Range)
7446
template<class P_numtype1, int N_length1>
7447
inline
7448
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7449
_bz_VecExprConstant<double>,
7450
Range > >
7451
where(const TinyVector<P_numtype1, N_length1>& d1,
7452
double d2,
7453
Range d3)
7454
{
7455
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7456
_bz_VecExprConstant<double>,
7457
Range > T_expr;
7458
7459
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7460
_bz_VecExprConstant<double>(d2),
7461
d3));
7462
}
7463
7464
// where(TinyVector<P_numtype1, N_length1>, double, TinyVector<P_numtype3, N_length3>)
7465
template<class P_numtype1, int N_length1, class P_numtype3, int N_length3>
7466
inline
7467
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7468
_bz_VecExprConstant<double>,
7469
TinyVectorIterConst<P_numtype3, N_length3> > >
7470
where(const TinyVector<P_numtype1, N_length1>& d1,
7471
double d2,
7472
const TinyVector<P_numtype3, N_length3>& d3)
7473
{
7474
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7475
_bz_VecExprConstant<double>,
7476
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
7477
7478
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7479
_bz_VecExprConstant<double>(d2),
7480
d3.beginFast()));
7481
}
7482
7483
// where(TinyVector<P_numtype1, N_length1>, double, double)
7484
template<class P_numtype1, int N_length1>
7485
inline
7486
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7487
_bz_VecExprConstant<double>,
7488
_bz_VecExprConstant<double> > >
7489
where(const TinyVector<P_numtype1, N_length1>& d1,
7490
double d2,
7491
double d3)
7492
{
7493
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7494
_bz_VecExprConstant<double>,
7495
_bz_VecExprConstant<double> > T_expr;
7496
7497
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7498
_bz_VecExprConstant<double>(d2),
7499
_bz_VecExprConstant<double>(d3)));
7500
}
7501
7502
// where(TinyVector<P_numtype1, N_length1>, long double, Vector<P_numtype3>)
7503
template<class P_numtype1, int N_length1, class P_numtype3>
7504
inline
7505
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7506
_bz_VecExprConstant<long double>,
7507
VectorIterConst<P_numtype3> > >
7508
where(const TinyVector<P_numtype1, N_length1>& d1,
7509
long double d2,
7510
const Vector<P_numtype3>& d3)
7511
{
7512
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7513
_bz_VecExprConstant<long double>,
7514
VectorIterConst<P_numtype3> > T_expr;
7515
7516
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7517
_bz_VecExprConstant<long double>(d2),
7518
d3.beginFast()));
7519
}
7520
7521
// where(TinyVector<P_numtype1, N_length1>, long double, _bz_VecExpr<P_expr3>)
7522
template<class P_numtype1, int N_length1, class P_expr3>
7523
inline
7524
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7525
_bz_VecExprConstant<long double>,
7526
_bz_VecExpr<P_expr3> > >
7527
where(const TinyVector<P_numtype1, N_length1>& d1,
7528
long double d2,
7529
_bz_VecExpr<P_expr3> d3)
7530
{
7531
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7532
_bz_VecExprConstant<long double>,
7533
_bz_VecExpr<P_expr3> > T_expr;
7534
7535
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7536
_bz_VecExprConstant<long double>(d2),
7537
d3));
7538
}
7539
7540
// where(TinyVector<P_numtype1, N_length1>, long double, VectorPick<P_numtype3>)
7541
template<class P_numtype1, int N_length1, class P_numtype3>
7542
inline
7543
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7544
_bz_VecExprConstant<long double>,
7545
VectorPickIterConst<P_numtype3> > >
7546
where(const TinyVector<P_numtype1, N_length1>& d1,
7547
long double d2,
7548
const VectorPick<P_numtype3>& d3)
7549
{
7550
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7551
_bz_VecExprConstant<long double>,
7552
VectorPickIterConst<P_numtype3> > T_expr;
7553
7554
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7555
_bz_VecExprConstant<long double>(d2),
7556
d3.beginFast()));
7557
}
7558
7559
// where(TinyVector<P_numtype1, N_length1>, long double, Range)
7560
template<class P_numtype1, int N_length1>
7561
inline
7562
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7563
_bz_VecExprConstant<long double>,
7564
Range > >
7565
where(const TinyVector<P_numtype1, N_length1>& d1,
7566
long double d2,
7567
Range d3)
7568
{
7569
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7570
_bz_VecExprConstant<long double>,
7571
Range > T_expr;
7572
7573
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7574
_bz_VecExprConstant<long double>(d2),
7575
d3));
7576
}
7577
7578
// where(TinyVector<P_numtype1, N_length1>, long double, TinyVector<P_numtype3, N_length3>)
7579
template<class P_numtype1, int N_length1, class P_numtype3, int N_length3>
7580
inline
7581
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7582
_bz_VecExprConstant<long double>,
7583
TinyVectorIterConst<P_numtype3, N_length3> > >
7584
where(const TinyVector<P_numtype1, N_length1>& d1,
7585
long double d2,
7586
const TinyVector<P_numtype3, N_length3>& d3)
7587
{
7588
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7589
_bz_VecExprConstant<long double>,
7590
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
7591
7592
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7593
_bz_VecExprConstant<long double>(d2),
7594
d3.beginFast()));
7595
}
7596
7597
// where(TinyVector<P_numtype1, N_length1>, long double, long double)
7598
template<class P_numtype1, int N_length1>
7599
inline
7600
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7601
_bz_VecExprConstant<long double>,
7602
_bz_VecExprConstant<long double> > >
7603
where(const TinyVector<P_numtype1, N_length1>& d1,
7604
long double d2,
7605
long double d3)
7606
{
7607
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7608
_bz_VecExprConstant<long double>,
7609
_bz_VecExprConstant<long double> > T_expr;
7610
7611
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7612
_bz_VecExprConstant<long double>(d2),
7613
_bz_VecExprConstant<long double>(d3)));
7614
}
7615
7616
// where(TinyVector<P_numtype1, N_length1>, complex<T2>, Vector<P_numtype3>)
7617
#ifdef BZ_HAVE_COMPLEX
7618
template<class P_numtype1, int N_length1, class T2, class P_numtype3>
7619
inline
7620
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7621
_bz_VecExprConstant<complex<T2> > ,
7622
VectorIterConst<P_numtype3> > >
7623
where(const TinyVector<P_numtype1, N_length1>& d1,
7624
complex<T2> d2,
7625
const Vector<P_numtype3>& d3)
7626
{
7627
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7628
_bz_VecExprConstant<complex<T2> > ,
7629
VectorIterConst<P_numtype3> > T_expr;
7630
7631
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7632
_bz_VecExprConstant<complex<T2> > (d2),
7633
d3.beginFast()));
7634
}
7635
#endif // BZ_HAVE_COMPLEX
7636
7637
// where(TinyVector<P_numtype1, N_length1>, complex<T2>, _bz_VecExpr<P_expr3>)
7638
#ifdef BZ_HAVE_COMPLEX
7639
template<class P_numtype1, int N_length1, class T2, class P_expr3>
7640
inline
7641
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7642
_bz_VecExprConstant<complex<T2> > ,
7643
_bz_VecExpr<P_expr3> > >
7644
where(const TinyVector<P_numtype1, N_length1>& d1,
7645
complex<T2> d2,
7646
_bz_VecExpr<P_expr3> d3)
7647
{
7648
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7649
_bz_VecExprConstant<complex<T2> > ,
7650
_bz_VecExpr<P_expr3> > T_expr;
7651
7652
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7653
_bz_VecExprConstant<complex<T2> > (d2),
7654
d3));
7655
}
7656
#endif // BZ_HAVE_COMPLEX
7657
7658
// where(TinyVector<P_numtype1, N_length1>, complex<T2>, VectorPick<P_numtype3>)
7659
#ifdef BZ_HAVE_COMPLEX
7660
template<class P_numtype1, int N_length1, class T2, class P_numtype3>
7661
inline
7662
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7663
_bz_VecExprConstant<complex<T2> > ,
7664
VectorPickIterConst<P_numtype3> > >
7665
where(const TinyVector<P_numtype1, N_length1>& d1,
7666
complex<T2> d2,
7667
const VectorPick<P_numtype3>& d3)
7668
{
7669
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7670
_bz_VecExprConstant<complex<T2> > ,
7671
VectorPickIterConst<P_numtype3> > T_expr;
7672
7673
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7674
_bz_VecExprConstant<complex<T2> > (d2),
7675
d3.beginFast()));
7676
}
7677
#endif // BZ_HAVE_COMPLEX
7678
7679
// where(TinyVector<P_numtype1, N_length1>, complex<T2>, Range)
7680
#ifdef BZ_HAVE_COMPLEX
7681
template<class P_numtype1, int N_length1, class T2>
7682
inline
7683
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7684
_bz_VecExprConstant<complex<T2> > ,
7685
Range > >
7686
where(const TinyVector<P_numtype1, N_length1>& d1,
7687
complex<T2> d2,
7688
Range d3)
7689
{
7690
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7691
_bz_VecExprConstant<complex<T2> > ,
7692
Range > T_expr;
7693
7694
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7695
_bz_VecExprConstant<complex<T2> > (d2),
7696
d3));
7697
}
7698
#endif // BZ_HAVE_COMPLEX
7699
7700
// where(TinyVector<P_numtype1, N_length1>, complex<T2>, TinyVector<P_numtype3, N_length3>)
7701
#ifdef BZ_HAVE_COMPLEX
7702
template<class P_numtype1, int N_length1, class T2, class P_numtype3, int N_length3>
7703
inline
7704
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7705
_bz_VecExprConstant<complex<T2> > ,
7706
TinyVectorIterConst<P_numtype3, N_length3> > >
7707
where(const TinyVector<P_numtype1, N_length1>& d1,
7708
complex<T2> d2,
7709
const TinyVector<P_numtype3, N_length3>& d3)
7710
{
7711
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7712
_bz_VecExprConstant<complex<T2> > ,
7713
TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
7714
7715
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7716
_bz_VecExprConstant<complex<T2> > (d2),
7717
d3.beginFast()));
7718
}
7719
#endif // BZ_HAVE_COMPLEX
7720
7721
// where(TinyVector<P_numtype1, N_length1>, complex<T2>, complex<T3>)
7722
#ifdef BZ_HAVE_COMPLEX
7723
template<class P_numtype1, int N_length1, class T2, class T3>
7724
inline
7725
_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7726
_bz_VecExprConstant<complex<T2> > ,
7727
_bz_VecExprConstant<complex<T3> > > >
7728
where(const TinyVector<P_numtype1, N_length1>& d1,
7729
complex<T2> d2,
7730
complex<T3> d3)
7731
{
7732
typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>,
7733
_bz_VecExprConstant<complex<T2> > ,
7734
_bz_VecExprConstant<complex<T3> > > T_expr;
7735
7736
return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(),
7737
_bz_VecExprConstant<complex<T2> > (d2),
7738
_bz_VecExprConstant<complex<T3> > (d3)));
7739
}
7740
#endif // BZ_HAVE_COMPLEX
7741
7742
BZ_NAMESPACE_END
7743
7744
#endif
Loggerhead is a web-based interface for Breezy
Version: 2.0.1