Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

bops.cc@ 2782

Visit:

Last change on this file since 2782 was 221, checked in by ansari, 27 years ago
Creation module DPC/Blitz (blitz 0.4) Reza 09/04/99
File size: 253.3 KB

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

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

Context Navigation

source: Sophya/trunk/SophyaExt/Blitz/blitz/array/bops.cc@ 2782

Download in other formats: