← Back to branch summary

~ubuntu-branches/ubuntu/raring/python-scipy/raring-proposed

« back to all changes in this revision

Viewing changes to Lib/weave/blitz/blitz/array/bops.cc

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-01-07 14:12:12 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070107141212-mm0ebkh5b37hcpzn
http://bugs.debian.org/402783
* Remove build dependency on python-numpy-dev.
* python-scipy: Depend on python-numpy instead of python-numpy-dev.
* Package builds on other archs than i386. Closes: #402783.

Show diffs side-by-side

added added

removed removed

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