Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

bops.cc@ 4031

Visit:

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

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

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

Context Navigation

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

Download in other formats: