Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

vecwhere.cc@ 658

Visit:

Last change on this file since 658 was 658, checked in by ansari, 26 years ago
no message
File size: 229.4 KB

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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: Sophya/trunk/Poubelle/DPC:FitsIOServer/Blitz/blitz/vecwhere.cc@ 658

Download in other formats: