Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

bops.cc@ 658

Visit:

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

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

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

Context Navigation

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

Download in other formats: