Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
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

Rev	Line
[658]	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: