« back to all changes in this revision
Viewing changes to blitz/array/uops.cc
- browse files at revision 16
- compare with another revision
- download diff
- download tarball
- view history from revision 16
- Committer: Package Import Robot
- Author(s): Christophe Trophime
- Date: 2012-07-06 09:15:30 UTC
- mfrom: (11.1.5 sid)
- Revision ID: package-import@ubuntu.com-20120706091530-vzrb8zf0vpbf8tp9
Tags: 1:0.10-1
* New upstream release
Closes: #679407
* debian/rules:
- update for new release
- add override_dh_auto_test target
- regenerate configure and Makefile.am
* debian/control:
- add libtool, automake to BuildDepends
* debian/libblitz-doc.install
- modify path for html files
* remove uneeded patches
* add examples.patch
Closes: #679407
* debian/rules:
- update for new release
- add override_dh_auto_test target
- regenerate configure and Makefile.am
* debian/control:
- add libtool, automake to BuildDepends
* debian/libblitz-doc.install
- modify path for html files
* remove uneeded patches
* add examples.patch
- files added:
- .pc/.quilt_patches
- .pc/examples.patch
- .pc/examples.patch/examples
- files removed:
- .pc/01_gcc34_amd64.patch
- .pc/01_gcc34_amd64.patch/blitz
- .pc/01_gcc_43_missing_includes.patch
- .pc/01_gcc_43_missing_includes.patch/blitz
- .pc/30_fix_doxygen_install_target.patch
- .pc/30_fix_doxygen_install_target.patch/doc
- .pc/30_fix_doxygen_install_target.patch/doc/doxygen
- .pc/40_prevent_celetion_of_texi_files.patch
- .pc/40_prevent_celetion_of_texi_files.patch/doc
- .pc/40_prevent_celetion_of_texi_files.patch/doc/examples
- .pc/40_prevent_celetion_of_texi_files.patch/doc/stencils
- files modified:
- .pc/applied-patches
added
removed
blitz/array/uops.cc
1
/***************************************************************************
2
* blitz/../array/uops.cc Expression templates for arrays, unary functions
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
// genarruops.cpp Dec 30 2003 16:49:07
26
27
#ifndef BZ_ARRAYUOPS_CC
28
#define BZ_ARRAYUOPS_CC
29
30
#ifndef BZ_ARRAYEXPR_H
31
#error <blitz/array/uops.cc> must be included after <blitz/arrayexpr.h>
32
#endif // BZ_ARRAYEXPR_H
33
34
BZ_NAMESPACE(blitz)
35
36
/****************************************************************************
37
* abs
38
****************************************************************************/
39
40
template<class T_numtype1, int N_rank1>
41
inline
42
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
43
_bz_abs<T_numtype1> > >
44
abs(const Array<T_numtype1, N_rank1>& d1)
45
{
46
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
47
_bz_abs<T_numtype1> >(d1.begin());
48
}
49
50
template<class P_expr1>
51
inline
52
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
53
_bz_abs<typename P_expr1::T_numtype> > >
54
abs(_bz_ArrayExpr<P_expr1> d1)
55
{
56
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
57
_bz_abs<typename P_expr1::T_numtype> >(d1);
58
}
59
60
template<int N_index1>
61
inline
62
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
63
_bz_abs<int> > >
64
abs(IndexPlaceholder<N_index1> d1)
65
{
66
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
67
_bz_abs<int> >(d1);
68
}
69
70
71
/****************************************************************************
72
* acos
73
****************************************************************************/
74
75
template<class T_numtype1, int N_rank1>
76
inline
77
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
78
_bz_acos<T_numtype1> > >
79
acos(const Array<T_numtype1, N_rank1>& d1)
80
{
81
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
82
_bz_acos<T_numtype1> >(d1.begin());
83
}
84
85
template<class P_expr1>
86
inline
87
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
88
_bz_acos<typename P_expr1::T_numtype> > >
89
acos(_bz_ArrayExpr<P_expr1> d1)
90
{
91
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
92
_bz_acos<typename P_expr1::T_numtype> >(d1);
93
}
94
95
template<int N_index1>
96
inline
97
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
98
_bz_acos<int> > >
99
acos(IndexPlaceholder<N_index1> d1)
100
{
101
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
102
_bz_acos<int> >(d1);
103
}
104
105
106
/****************************************************************************
107
* acosh
108
****************************************************************************/
109
110
#ifdef BZ_HAVE_IEEE_MATH
111
template<class T_numtype1, int N_rank1>
112
inline
113
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
114
_bz_acosh<T_numtype1> > >
115
acosh(const Array<T_numtype1, N_rank1>& d1)
116
{
117
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
118
_bz_acosh<T_numtype1> >(d1.begin());
119
}
120
121
template<class P_expr1>
122
inline
123
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
124
_bz_acosh<typename P_expr1::T_numtype> > >
125
acosh(_bz_ArrayExpr<P_expr1> d1)
126
{
127
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
128
_bz_acosh<typename P_expr1::T_numtype> >(d1);
129
}
130
131
template<int N_index1>
132
inline
133
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
134
_bz_acosh<int> > >
135
acosh(IndexPlaceholder<N_index1> d1)
136
{
137
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
138
_bz_acosh<int> >(d1);
139
}
140
141
#endif
142
143
/****************************************************************************
144
* asin
145
****************************************************************************/
146
147
template<class T_numtype1, int N_rank1>
148
inline
149
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
150
_bz_asin<T_numtype1> > >
151
asin(const Array<T_numtype1, N_rank1>& d1)
152
{
153
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
154
_bz_asin<T_numtype1> >(d1.begin());
155
}
156
157
template<class P_expr1>
158
inline
159
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
160
_bz_asin<typename P_expr1::T_numtype> > >
161
asin(_bz_ArrayExpr<P_expr1> d1)
162
{
163
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
164
_bz_asin<typename P_expr1::T_numtype> >(d1);
165
}
166
167
template<int N_index1>
168
inline
169
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
170
_bz_asin<int> > >
171
asin(IndexPlaceholder<N_index1> d1)
172
{
173
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
174
_bz_asin<int> >(d1);
175
}
176
177
178
/****************************************************************************
179
* asinh
180
****************************************************************************/
181
182
#ifdef BZ_HAVE_IEEE_MATH
183
template<class T_numtype1, int N_rank1>
184
inline
185
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
186
_bz_asinh<T_numtype1> > >
187
asinh(const Array<T_numtype1, N_rank1>& d1)
188
{
189
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
190
_bz_asinh<T_numtype1> >(d1.begin());
191
}
192
193
template<class P_expr1>
194
inline
195
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
196
_bz_asinh<typename P_expr1::T_numtype> > >
197
asinh(_bz_ArrayExpr<P_expr1> d1)
198
{
199
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
200
_bz_asinh<typename P_expr1::T_numtype> >(d1);
201
}
202
203
template<int N_index1>
204
inline
205
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
206
_bz_asinh<int> > >
207
asinh(IndexPlaceholder<N_index1> d1)
208
{
209
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
210
_bz_asinh<int> >(d1);
211
}
212
213
#endif
214
215
/****************************************************************************
216
* atan
217
****************************************************************************/
218
219
template<class T_numtype1, int N_rank1>
220
inline
221
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
222
_bz_atan<T_numtype1> > >
223
atan(const Array<T_numtype1, N_rank1>& d1)
224
{
225
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
226
_bz_atan<T_numtype1> >(d1.begin());
227
}
228
229
template<class P_expr1>
230
inline
231
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
232
_bz_atan<typename P_expr1::T_numtype> > >
233
atan(_bz_ArrayExpr<P_expr1> d1)
234
{
235
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
236
_bz_atan<typename P_expr1::T_numtype> >(d1);
237
}
238
239
template<int N_index1>
240
inline
241
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
242
_bz_atan<int> > >
243
atan(IndexPlaceholder<N_index1> d1)
244
{
245
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
246
_bz_atan<int> >(d1);
247
}
248
249
250
/****************************************************************************
251
* atanh
252
****************************************************************************/
253
254
#ifdef BZ_HAVE_IEEE_MATH
255
template<class T_numtype1, int N_rank1>
256
inline
257
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
258
_bz_atanh<T_numtype1> > >
259
atanh(const Array<T_numtype1, N_rank1>& d1)
260
{
261
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
262
_bz_atanh<T_numtype1> >(d1.begin());
263
}
264
265
template<class P_expr1>
266
inline
267
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
268
_bz_atanh<typename P_expr1::T_numtype> > >
269
atanh(_bz_ArrayExpr<P_expr1> d1)
270
{
271
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
272
_bz_atanh<typename P_expr1::T_numtype> >(d1);
273
}
274
275
template<int N_index1>
276
inline
277
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
278
_bz_atanh<int> > >
279
atanh(IndexPlaceholder<N_index1> d1)
280
{
281
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
282
_bz_atanh<int> >(d1);
283
}
284
285
#endif
286
287
/****************************************************************************
288
* atan2
289
****************************************************************************/
290
291
template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>
292
inline
293
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
294
_bz_atan2<T_numtype1,T_numtype2> > >
295
atan2(const Array<T_numtype1, N_rank1>& d1, const Array<T_numtype2, N_rank2>& d2)
296
{
297
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
298
_bz_atan2<T_numtype1,T_numtype2> >(d1.begin(), d2.begin());
299
}
300
301
template<class T_numtype1, int N_rank1, class P_expr2>
302
inline
303
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
304
_bz_atan2<T_numtype1,typename P_expr2::T_numtype> > >
305
atan2(const Array<T_numtype1, N_rank1>& d1, _bz_ArrayExpr<P_expr2> d2)
306
{
307
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
308
_bz_atan2<T_numtype1,typename P_expr2::T_numtype> >(d1.begin(), d2);
309
}
310
311
template<class T_numtype1, int N_rank1, int N_index2>
312
inline
313
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
314
_bz_atan2<T_numtype1,int> > >
315
atan2(const Array<T_numtype1, N_rank1>& d1, IndexPlaceholder<N_index2> d2)
316
{
317
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
318
_bz_atan2<T_numtype1,int> >(d1.begin(), d2);
319
}
320
321
template<class T_numtype1, int N_rank1>
322
inline
323
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
324
_bz_atan2<T_numtype1,float> > >
325
atan2(const Array<T_numtype1, N_rank1>& d1, float d2)
326
{
327
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
328
_bz_atan2<T_numtype1,float> >(d1.begin(), _bz_ArrayExprConstant<float>(d2));
329
}
330
331
template<class T_numtype1, int N_rank1>
332
inline
333
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
334
_bz_atan2<T_numtype1,double> > >
335
atan2(const Array<T_numtype1, N_rank1>& d1, double d2)
336
{
337
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
338
_bz_atan2<T_numtype1,double> >(d1.begin(), _bz_ArrayExprConstant<double>(d2));
339
}
340
341
template<class T_numtype1, int N_rank1>
342
inline
343
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
344
_bz_atan2<T_numtype1,long double> > >
345
atan2(const Array<T_numtype1, N_rank1>& d1, long double d2)
346
{
347
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
348
_bz_atan2<T_numtype1,long double> >(d1.begin(), _bz_ArrayExprConstant<long double>(d2));
349
}
350
351
#ifdef BZ_HAVE_COMPLEX
352
template<class T_numtype1, int N_rank1, class T2>
353
inline
354
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
355
_bz_atan2<T_numtype1,complex<T2> > > >
356
atan2(const Array<T_numtype1, N_rank1>& d1, complex<T2> d2)
357
{
358
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
359
_bz_atan2<T_numtype1,complex<T2> > >(d1.begin(), _bz_ArrayExprConstant<complex<T2> > (d2));
360
}
361
362
#endif // BZ_HAVE_COMPLEX
363
364
template<class P_expr1, class T_numtype2, int N_rank2>
365
inline
366
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
367
_bz_atan2<typename P_expr1::T_numtype,T_numtype2> > >
368
atan2(_bz_ArrayExpr<P_expr1> d1, const Array<T_numtype2, N_rank2>& d2)
369
{
370
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
371
_bz_atan2<typename P_expr1::T_numtype,T_numtype2> >(d1, d2.begin());
372
}
373
374
template<class P_expr1, class P_expr2>
375
inline
376
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
377
_bz_atan2<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
378
atan2(_bz_ArrayExpr<P_expr1> d1, _bz_ArrayExpr<P_expr2> d2)
379
{
380
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
381
_bz_atan2<typename P_expr1::T_numtype,typename P_expr2::T_numtype> >(d1, d2);
382
}
383
384
template<class P_expr1, int N_index2>
385
inline
386
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
387
_bz_atan2<typename P_expr1::T_numtype,int> > >
388
atan2(_bz_ArrayExpr<P_expr1> d1, IndexPlaceholder<N_index2> d2)
389
{
390
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
391
_bz_atan2<typename P_expr1::T_numtype,int> >(d1, d2);
392
}
393
394
template<class P_expr1>
395
inline
396
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
397
_bz_atan2<typename P_expr1::T_numtype,float> > >
398
atan2(_bz_ArrayExpr<P_expr1> d1, float d2)
399
{
400
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
401
_bz_atan2<typename P_expr1::T_numtype,float> >(d1, _bz_ArrayExprConstant<float>(d2));
402
}
403
404
template<class P_expr1>
405
inline
406
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
407
_bz_atan2<typename P_expr1::T_numtype,double> > >
408
atan2(_bz_ArrayExpr<P_expr1> d1, double d2)
409
{
410
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
411
_bz_atan2<typename P_expr1::T_numtype,double> >(d1, _bz_ArrayExprConstant<double>(d2));
412
}
413
414
template<class P_expr1>
415
inline
416
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
417
_bz_atan2<typename P_expr1::T_numtype,long double> > >
418
atan2(_bz_ArrayExpr<P_expr1> d1, long double d2)
419
{
420
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
421
_bz_atan2<typename P_expr1::T_numtype,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
422
}
423
424
#ifdef BZ_HAVE_COMPLEX
425
template<class P_expr1, class T2>
426
inline
427
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
428
_bz_atan2<typename P_expr1::T_numtype,complex<T2> > > >
429
atan2(_bz_ArrayExpr<P_expr1> d1, complex<T2> d2)
430
{
431
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
432
_bz_atan2<typename P_expr1::T_numtype,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
433
}
434
435
#endif // BZ_HAVE_COMPLEX
436
437
template<int N_index1, class T_numtype2, int N_rank2>
438
inline
439
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
440
_bz_atan2<int,T_numtype2> > >
441
atan2(IndexPlaceholder<N_index1> d1, const Array<T_numtype2, N_rank2>& d2)
442
{
443
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
444
_bz_atan2<int,T_numtype2> >(d1, d2.begin());
445
}
446
447
template<int N_index1, class P_expr2>
448
inline
449
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
450
_bz_atan2<int,typename P_expr2::T_numtype> > >
451
atan2(IndexPlaceholder<N_index1> d1, _bz_ArrayExpr<P_expr2> d2)
452
{
453
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
454
_bz_atan2<int,typename P_expr2::T_numtype> >(d1, d2);
455
}
456
457
template<int N_index1, int N_index2>
458
inline
459
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
460
_bz_atan2<int,int> > >
461
atan2(IndexPlaceholder<N_index1> d1, IndexPlaceholder<N_index2> d2)
462
{
463
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
464
_bz_atan2<int,int> >(d1, d2);
465
}
466
467
template<int N_index1>
468
inline
469
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
470
_bz_atan2<int,float> > >
471
atan2(IndexPlaceholder<N_index1> d1, float d2)
472
{
473
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
474
_bz_atan2<int,float> >(d1, _bz_ArrayExprConstant<float>(d2));
475
}
476
477
template<int N_index1>
478
inline
479
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
480
_bz_atan2<int,double> > >
481
atan2(IndexPlaceholder<N_index1> d1, double d2)
482
{
483
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
484
_bz_atan2<int,double> >(d1, _bz_ArrayExprConstant<double>(d2));
485
}
486
487
template<int N_index1>
488
inline
489
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
490
_bz_atan2<int,long double> > >
491
atan2(IndexPlaceholder<N_index1> d1, long double d2)
492
{
493
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
494
_bz_atan2<int,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
495
}
496
497
#ifdef BZ_HAVE_COMPLEX
498
template<int N_index1, class T2>
499
inline
500
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
501
_bz_atan2<int,complex<T2> > > >
502
atan2(IndexPlaceholder<N_index1> d1, complex<T2> d2)
503
{
504
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
505
_bz_atan2<int,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
506
}
507
508
#endif // BZ_HAVE_COMPLEX
509
510
template<class T_numtype2, int N_rank2>
511
inline
512
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
513
_bz_atan2<float,T_numtype2> > >
514
atan2(float d1, const Array<T_numtype2, N_rank2>& d2)
515
{
516
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
517
_bz_atan2<float,T_numtype2> >(_bz_ArrayExprConstant<float>(d1), d2.begin());
518
}
519
520
template<class P_expr2>
521
inline
522
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
523
_bz_atan2<float,typename P_expr2::T_numtype> > >
524
atan2(float d1, _bz_ArrayExpr<P_expr2> d2)
525
{
526
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
527
_bz_atan2<float,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<float>(d1), d2);
528
}
529
530
template<int N_index2>
531
inline
532
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
533
_bz_atan2<float,int> > >
534
atan2(float d1, IndexPlaceholder<N_index2> d2)
535
{
536
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
537
_bz_atan2<float,int> >(_bz_ArrayExprConstant<float>(d1), d2);
538
}
539
540
template<class T_numtype2, int N_rank2>
541
inline
542
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
543
_bz_atan2<double,T_numtype2> > >
544
atan2(double d1, const Array<T_numtype2, N_rank2>& d2)
545
{
546
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
547
_bz_atan2<double,T_numtype2> >(_bz_ArrayExprConstant<double>(d1), d2.begin());
548
}
549
550
template<class P_expr2>
551
inline
552
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
553
_bz_atan2<double,typename P_expr2::T_numtype> > >
554
atan2(double d1, _bz_ArrayExpr<P_expr2> d2)
555
{
556
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
557
_bz_atan2<double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<double>(d1), d2);
558
}
559
560
template<int N_index2>
561
inline
562
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
563
_bz_atan2<double,int> > >
564
atan2(double d1, IndexPlaceholder<N_index2> d2)
565
{
566
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
567
_bz_atan2<double,int> >(_bz_ArrayExprConstant<double>(d1), d2);
568
}
569
570
template<class T_numtype2, int N_rank2>
571
inline
572
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
573
_bz_atan2<long double,T_numtype2> > >
574
atan2(long double d1, const Array<T_numtype2, N_rank2>& d2)
575
{
576
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
577
_bz_atan2<long double,T_numtype2> >(_bz_ArrayExprConstant<long double>(d1), d2.begin());
578
}
579
580
template<class P_expr2>
581
inline
582
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
583
_bz_atan2<long double,typename P_expr2::T_numtype> > >
584
atan2(long double d1, _bz_ArrayExpr<P_expr2> d2)
585
{
586
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
587
_bz_atan2<long double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<long double>(d1), d2);
588
}
589
590
template<int N_index2>
591
inline
592
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
593
_bz_atan2<long double,int> > >
594
atan2(long double d1, IndexPlaceholder<N_index2> d2)
595
{
596
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
597
_bz_atan2<long double,int> >(_bz_ArrayExprConstant<long double>(d1), d2);
598
}
599
600
#ifdef BZ_HAVE_COMPLEX
601
template<class T1, class T_numtype2, int N_rank2>
602
inline
603
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
604
_bz_atan2<complex<T1> ,T_numtype2> > >
605
atan2(complex<T1> d1, const Array<T_numtype2, N_rank2>& d2)
606
{
607
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
608
_bz_atan2<complex<T1> ,T_numtype2> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2.begin());
609
}
610
611
#endif // BZ_HAVE_COMPLEX
612
613
#ifdef BZ_HAVE_COMPLEX
614
template<class T1, class P_expr2>
615
inline
616
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
617
_bz_atan2<complex<T1> ,typename P_expr2::T_numtype> > >
618
atan2(complex<T1> d1, _bz_ArrayExpr<P_expr2> d2)
619
{
620
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
621
_bz_atan2<complex<T1> ,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
622
}
623
624
#endif // BZ_HAVE_COMPLEX
625
626
#ifdef BZ_HAVE_COMPLEX
627
template<class T1, int N_index2>
628
inline
629
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
630
_bz_atan2<complex<T1> ,int> > >
631
atan2(complex<T1> d1, IndexPlaceholder<N_index2> d2)
632
{
633
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
634
_bz_atan2<complex<T1> ,int> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
635
}
636
637
#endif // BZ_HAVE_COMPLEX
638
639
640
/****************************************************************************
641
* _class
642
****************************************************************************/
643
644
#ifdef BZ_HAVE_SYSTEM_V_MATH
645
template<class T_numtype1, int N_rank1>
646
inline
647
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
648
_bz__class<T_numtype1> > >
649
_class(const Array<T_numtype1, N_rank1>& d1)
650
{
651
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
652
_bz__class<T_numtype1> >(d1.begin());
653
}
654
655
template<class P_expr1>
656
inline
657
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
658
_bz__class<typename P_expr1::T_numtype> > >
659
_class(_bz_ArrayExpr<P_expr1> d1)
660
{
661
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
662
_bz__class<typename P_expr1::T_numtype> >(d1);
663
}
664
665
template<int N_index1>
666
inline
667
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
668
_bz__class<int> > >
669
_class(IndexPlaceholder<N_index1> d1)
670
{
671
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
672
_bz__class<int> >(d1);
673
}
674
675
#endif
676
677
/****************************************************************************
678
* cbrt
679
****************************************************************************/
680
681
#ifdef BZ_HAVE_IEEE_MATH
682
template<class T_numtype1, int N_rank1>
683
inline
684
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
685
_bz_cbrt<T_numtype1> > >
686
cbrt(const Array<T_numtype1, N_rank1>& d1)
687
{
688
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
689
_bz_cbrt<T_numtype1> >(d1.begin());
690
}
691
692
template<class P_expr1>
693
inline
694
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
695
_bz_cbrt<typename P_expr1::T_numtype> > >
696
cbrt(_bz_ArrayExpr<P_expr1> d1)
697
{
698
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
699
_bz_cbrt<typename P_expr1::T_numtype> >(d1);
700
}
701
702
template<int N_index1>
703
inline
704
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
705
_bz_cbrt<int> > >
706
cbrt(IndexPlaceholder<N_index1> d1)
707
{
708
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
709
_bz_cbrt<int> >(d1);
710
}
711
712
#endif
713
714
/****************************************************************************
715
* ceil
716
****************************************************************************/
717
718
template<class T_numtype1, int N_rank1>
719
inline
720
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
721
_bz_ceil<T_numtype1> > >
722
ceil(const Array<T_numtype1, N_rank1>& d1)
723
{
724
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
725
_bz_ceil<T_numtype1> >(d1.begin());
726
}
727
728
template<class P_expr1>
729
inline
730
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
731
_bz_ceil<typename P_expr1::T_numtype> > >
732
ceil(_bz_ArrayExpr<P_expr1> d1)
733
{
734
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
735
_bz_ceil<typename P_expr1::T_numtype> >(d1);
736
}
737
738
template<int N_index1>
739
inline
740
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
741
_bz_ceil<int> > >
742
ceil(IndexPlaceholder<N_index1> d1)
743
{
744
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
745
_bz_ceil<int> >(d1);
746
}
747
748
749
/****************************************************************************
750
* cexp
751
****************************************************************************/
752
753
template<class T_numtype1, int N_rank1>
754
inline
755
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
756
_bz_cexp<T_numtype1> > >
757
cexp(const Array<T_numtype1, N_rank1>& d1)
758
{
759
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
760
_bz_cexp<T_numtype1> >(d1.begin());
761
}
762
763
template<class P_expr1>
764
inline
765
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
766
_bz_cexp<typename P_expr1::T_numtype> > >
767
cexp(_bz_ArrayExpr<P_expr1> d1)
768
{
769
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
770
_bz_cexp<typename P_expr1::T_numtype> >(d1);
771
}
772
773
template<int N_index1>
774
inline
775
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
776
_bz_cexp<int> > >
777
cexp(IndexPlaceholder<N_index1> d1)
778
{
779
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
780
_bz_cexp<int> >(d1);
781
}
782
783
784
/****************************************************************************
785
* cos
786
****************************************************************************/
787
788
template<class T_numtype1, int N_rank1>
789
inline
790
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
791
_bz_cos<T_numtype1> > >
792
cos(const Array<T_numtype1, N_rank1>& d1)
793
{
794
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
795
_bz_cos<T_numtype1> >(d1.begin());
796
}
797
798
template<class P_expr1>
799
inline
800
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
801
_bz_cos<typename P_expr1::T_numtype> > >
802
cos(_bz_ArrayExpr<P_expr1> d1)
803
{
804
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
805
_bz_cos<typename P_expr1::T_numtype> >(d1);
806
}
807
808
template<int N_index1>
809
inline
810
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
811
_bz_cos<int> > >
812
cos(IndexPlaceholder<N_index1> d1)
813
{
814
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
815
_bz_cos<int> >(d1);
816
}
817
818
819
/****************************************************************************
820
* cosh
821
****************************************************************************/
822
823
template<class T_numtype1, int N_rank1>
824
inline
825
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
826
_bz_cosh<T_numtype1> > >
827
cosh(const Array<T_numtype1, N_rank1>& d1)
828
{
829
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
830
_bz_cosh<T_numtype1> >(d1.begin());
831
}
832
833
template<class P_expr1>
834
inline
835
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
836
_bz_cosh<typename P_expr1::T_numtype> > >
837
cosh(_bz_ArrayExpr<P_expr1> d1)
838
{
839
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
840
_bz_cosh<typename P_expr1::T_numtype> >(d1);
841
}
842
843
template<int N_index1>
844
inline
845
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
846
_bz_cosh<int> > >
847
cosh(IndexPlaceholder<N_index1> d1)
848
{
849
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
850
_bz_cosh<int> >(d1);
851
}
852
853
854
/****************************************************************************
855
* copysign
856
****************************************************************************/
857
858
#ifdef BZ_HAVE_SYSTEM_V_MATH
859
template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>
860
inline
861
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
862
_bz_copysign<T_numtype1,T_numtype2> > >
863
copysign(const Array<T_numtype1, N_rank1>& d1, const Array<T_numtype2, N_rank2>& d2)
864
{
865
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
866
_bz_copysign<T_numtype1,T_numtype2> >(d1.begin(), d2.begin());
867
}
868
869
template<class T_numtype1, int N_rank1, class P_expr2>
870
inline
871
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
872
_bz_copysign<T_numtype1,typename P_expr2::T_numtype> > >
873
copysign(const Array<T_numtype1, N_rank1>& d1, _bz_ArrayExpr<P_expr2> d2)
874
{
875
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
876
_bz_copysign<T_numtype1,typename P_expr2::T_numtype> >(d1.begin(), d2);
877
}
878
879
template<class T_numtype1, int N_rank1, int N_index2>
880
inline
881
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
882
_bz_copysign<T_numtype1,int> > >
883
copysign(const Array<T_numtype1, N_rank1>& d1, IndexPlaceholder<N_index2> d2)
884
{
885
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
886
_bz_copysign<T_numtype1,int> >(d1.begin(), d2);
887
}
888
889
template<class T_numtype1, int N_rank1>
890
inline
891
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
892
_bz_copysign<T_numtype1,float> > >
893
copysign(const Array<T_numtype1, N_rank1>& d1, float d2)
894
{
895
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
896
_bz_copysign<T_numtype1,float> >(d1.begin(), _bz_ArrayExprConstant<float>(d2));
897
}
898
899
template<class T_numtype1, int N_rank1>
900
inline
901
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
902
_bz_copysign<T_numtype1,double> > >
903
copysign(const Array<T_numtype1, N_rank1>& d1, double d2)
904
{
905
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
906
_bz_copysign<T_numtype1,double> >(d1.begin(), _bz_ArrayExprConstant<double>(d2));
907
}
908
909
template<class T_numtype1, int N_rank1>
910
inline
911
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
912
_bz_copysign<T_numtype1,long double> > >
913
copysign(const Array<T_numtype1, N_rank1>& d1, long double d2)
914
{
915
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
916
_bz_copysign<T_numtype1,long double> >(d1.begin(), _bz_ArrayExprConstant<long double>(d2));
917
}
918
919
#ifdef BZ_HAVE_COMPLEX
920
template<class T_numtype1, int N_rank1, class T2>
921
inline
922
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
923
_bz_copysign<T_numtype1,complex<T2> > > >
924
copysign(const Array<T_numtype1, N_rank1>& d1, complex<T2> d2)
925
{
926
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
927
_bz_copysign<T_numtype1,complex<T2> > >(d1.begin(), _bz_ArrayExprConstant<complex<T2> > (d2));
928
}
929
930
#endif // BZ_HAVE_COMPLEX
931
932
template<class P_expr1, class T_numtype2, int N_rank2>
933
inline
934
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
935
_bz_copysign<typename P_expr1::T_numtype,T_numtype2> > >
936
copysign(_bz_ArrayExpr<P_expr1> d1, const Array<T_numtype2, N_rank2>& d2)
937
{
938
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
939
_bz_copysign<typename P_expr1::T_numtype,T_numtype2> >(d1, d2.begin());
940
}
941
942
template<class P_expr1, class P_expr2>
943
inline
944
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
945
_bz_copysign<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
946
copysign(_bz_ArrayExpr<P_expr1> d1, _bz_ArrayExpr<P_expr2> d2)
947
{
948
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
949
_bz_copysign<typename P_expr1::T_numtype,typename P_expr2::T_numtype> >(d1, d2);
950
}
951
952
template<class P_expr1, int N_index2>
953
inline
954
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
955
_bz_copysign<typename P_expr1::T_numtype,int> > >
956
copysign(_bz_ArrayExpr<P_expr1> d1, IndexPlaceholder<N_index2> d2)
957
{
958
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
959
_bz_copysign<typename P_expr1::T_numtype,int> >(d1, d2);
960
}
961
962
template<class P_expr1>
963
inline
964
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
965
_bz_copysign<typename P_expr1::T_numtype,float> > >
966
copysign(_bz_ArrayExpr<P_expr1> d1, float d2)
967
{
968
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
969
_bz_copysign<typename P_expr1::T_numtype,float> >(d1, _bz_ArrayExprConstant<float>(d2));
970
}
971
972
template<class P_expr1>
973
inline
974
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
975
_bz_copysign<typename P_expr1::T_numtype,double> > >
976
copysign(_bz_ArrayExpr<P_expr1> d1, double d2)
977
{
978
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
979
_bz_copysign<typename P_expr1::T_numtype,double> >(d1, _bz_ArrayExprConstant<double>(d2));
980
}
981
982
template<class P_expr1>
983
inline
984
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
985
_bz_copysign<typename P_expr1::T_numtype,long double> > >
986
copysign(_bz_ArrayExpr<P_expr1> d1, long double d2)
987
{
988
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
989
_bz_copysign<typename P_expr1::T_numtype,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
990
}
991
992
#ifdef BZ_HAVE_COMPLEX
993
template<class P_expr1, class T2>
994
inline
995
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
996
_bz_copysign<typename P_expr1::T_numtype,complex<T2> > > >
997
copysign(_bz_ArrayExpr<P_expr1> d1, complex<T2> d2)
998
{
999
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
1000
_bz_copysign<typename P_expr1::T_numtype,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
1001
}
1002
1003
#endif // BZ_HAVE_COMPLEX
1004
1005
template<int N_index1, class T_numtype2, int N_rank2>
1006
inline
1007
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
1008
_bz_copysign<int,T_numtype2> > >
1009
copysign(IndexPlaceholder<N_index1> d1, const Array<T_numtype2, N_rank2>& d2)
1010
{
1011
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
1012
_bz_copysign<int,T_numtype2> >(d1, d2.begin());
1013
}
1014
1015
template<int N_index1, class P_expr2>
1016
inline
1017
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
1018
_bz_copysign<int,typename P_expr2::T_numtype> > >
1019
copysign(IndexPlaceholder<N_index1> d1, _bz_ArrayExpr<P_expr2> d2)
1020
{
1021
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
1022
_bz_copysign<int,typename P_expr2::T_numtype> >(d1, d2);
1023
}
1024
1025
template<int N_index1, int N_index2>
1026
inline
1027
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
1028
_bz_copysign<int,int> > >
1029
copysign(IndexPlaceholder<N_index1> d1, IndexPlaceholder<N_index2> d2)
1030
{
1031
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
1032
_bz_copysign<int,int> >(d1, d2);
1033
}
1034
1035
template<int N_index1>
1036
inline
1037
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
1038
_bz_copysign<int,float> > >
1039
copysign(IndexPlaceholder<N_index1> d1, float d2)
1040
{
1041
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
1042
_bz_copysign<int,float> >(d1, _bz_ArrayExprConstant<float>(d2));
1043
}
1044
1045
template<int N_index1>
1046
inline
1047
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
1048
_bz_copysign<int,double> > >
1049
copysign(IndexPlaceholder<N_index1> d1, double d2)
1050
{
1051
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
1052
_bz_copysign<int,double> >(d1, _bz_ArrayExprConstant<double>(d2));
1053
}
1054
1055
template<int N_index1>
1056
inline
1057
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
1058
_bz_copysign<int,long double> > >
1059
copysign(IndexPlaceholder<N_index1> d1, long double d2)
1060
{
1061
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
1062
_bz_copysign<int,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
1063
}
1064
1065
#ifdef BZ_HAVE_COMPLEX
1066
template<int N_index1, class T2>
1067
inline
1068
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
1069
_bz_copysign<int,complex<T2> > > >
1070
copysign(IndexPlaceholder<N_index1> d1, complex<T2> d2)
1071
{
1072
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
1073
_bz_copysign<int,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
1074
}
1075
1076
#endif // BZ_HAVE_COMPLEX
1077
1078
template<class T_numtype2, int N_rank2>
1079
inline
1080
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
1081
_bz_copysign<float,T_numtype2> > >
1082
copysign(float d1, const Array<T_numtype2, N_rank2>& d2)
1083
{
1084
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
1085
_bz_copysign<float,T_numtype2> >(_bz_ArrayExprConstant<float>(d1), d2.begin());
1086
}
1087
1088
template<class P_expr2>
1089
inline
1090
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
1091
_bz_copysign<float,typename P_expr2::T_numtype> > >
1092
copysign(float d1, _bz_ArrayExpr<P_expr2> d2)
1093
{
1094
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
1095
_bz_copysign<float,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<float>(d1), d2);
1096
}
1097
1098
template<int N_index2>
1099
inline
1100
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
1101
_bz_copysign<float,int> > >
1102
copysign(float d1, IndexPlaceholder<N_index2> d2)
1103
{
1104
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
1105
_bz_copysign<float,int> >(_bz_ArrayExprConstant<float>(d1), d2);
1106
}
1107
1108
template<class T_numtype2, int N_rank2>
1109
inline
1110
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
1111
_bz_copysign<double,T_numtype2> > >
1112
copysign(double d1, const Array<T_numtype2, N_rank2>& d2)
1113
{
1114
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
1115
_bz_copysign<double,T_numtype2> >(_bz_ArrayExprConstant<double>(d1), d2.begin());
1116
}
1117
1118
template<class P_expr2>
1119
inline
1120
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
1121
_bz_copysign<double,typename P_expr2::T_numtype> > >
1122
copysign(double d1, _bz_ArrayExpr<P_expr2> d2)
1123
{
1124
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
1125
_bz_copysign<double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<double>(d1), d2);
1126
}
1127
1128
template<int N_index2>
1129
inline
1130
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
1131
_bz_copysign<double,int> > >
1132
copysign(double d1, IndexPlaceholder<N_index2> d2)
1133
{
1134
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
1135
_bz_copysign<double,int> >(_bz_ArrayExprConstant<double>(d1), d2);
1136
}
1137
1138
template<class T_numtype2, int N_rank2>
1139
inline
1140
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
1141
_bz_copysign<long double,T_numtype2> > >
1142
copysign(long double d1, const Array<T_numtype2, N_rank2>& d2)
1143
{
1144
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
1145
_bz_copysign<long double,T_numtype2> >(_bz_ArrayExprConstant<long double>(d1), d2.begin());
1146
}
1147
1148
template<class P_expr2>
1149
inline
1150
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
1151
_bz_copysign<long double,typename P_expr2::T_numtype> > >
1152
copysign(long double d1, _bz_ArrayExpr<P_expr2> d2)
1153
{
1154
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
1155
_bz_copysign<long double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<long double>(d1), d2);
1156
}
1157
1158
template<int N_index2>
1159
inline
1160
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
1161
_bz_copysign<long double,int> > >
1162
copysign(long double d1, IndexPlaceholder<N_index2> d2)
1163
{
1164
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
1165
_bz_copysign<long double,int> >(_bz_ArrayExprConstant<long double>(d1), d2);
1166
}
1167
1168
#ifdef BZ_HAVE_COMPLEX
1169
template<class T1, class T_numtype2, int N_rank2>
1170
inline
1171
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
1172
_bz_copysign<complex<T1> ,T_numtype2> > >
1173
copysign(complex<T1> d1, const Array<T_numtype2, N_rank2>& d2)
1174
{
1175
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
1176
_bz_copysign<complex<T1> ,T_numtype2> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2.begin());
1177
}
1178
1179
#endif // BZ_HAVE_COMPLEX
1180
1181
#ifdef BZ_HAVE_COMPLEX
1182
template<class T1, class P_expr2>
1183
inline
1184
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
1185
_bz_copysign<complex<T1> ,typename P_expr2::T_numtype> > >
1186
copysign(complex<T1> d1, _bz_ArrayExpr<P_expr2> d2)
1187
{
1188
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
1189
_bz_copysign<complex<T1> ,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
1190
}
1191
1192
#endif // BZ_HAVE_COMPLEX
1193
1194
#ifdef BZ_HAVE_COMPLEX
1195
template<class T1, int N_index2>
1196
inline
1197
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
1198
_bz_copysign<complex<T1> ,int> > >
1199
copysign(complex<T1> d1, IndexPlaceholder<N_index2> d2)
1200
{
1201
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
1202
_bz_copysign<complex<T1> ,int> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
1203
}
1204
1205
#endif // BZ_HAVE_COMPLEX
1206
1207
#endif
1208
1209
/****************************************************************************
1210
* csqrt
1211
****************************************************************************/
1212
1213
template<class T_numtype1, int N_rank1>
1214
inline
1215
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1216
_bz_csqrt<T_numtype1> > >
1217
csqrt(const Array<T_numtype1, N_rank1>& d1)
1218
{
1219
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1220
_bz_csqrt<T_numtype1> >(d1.begin());
1221
}
1222
1223
template<class P_expr1>
1224
inline
1225
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1226
_bz_csqrt<typename P_expr1::T_numtype> > >
1227
csqrt(_bz_ArrayExpr<P_expr1> d1)
1228
{
1229
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1230
_bz_csqrt<typename P_expr1::T_numtype> >(d1);
1231
}
1232
1233
template<int N_index1>
1234
inline
1235
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1236
_bz_csqrt<int> > >
1237
csqrt(IndexPlaceholder<N_index1> d1)
1238
{
1239
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1240
_bz_csqrt<int> >(d1);
1241
}
1242
1243
1244
/****************************************************************************
1245
* drem
1246
****************************************************************************/
1247
1248
#ifdef BZ_HAVE_SYSTEM_V_MATH
1249
template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>
1250
inline
1251
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
1252
_bz_drem<T_numtype1,T_numtype2> > >
1253
drem(const Array<T_numtype1, N_rank1>& d1, const Array<T_numtype2, N_rank2>& d2)
1254
{
1255
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
1256
_bz_drem<T_numtype1,T_numtype2> >(d1.begin(), d2.begin());
1257
}
1258
1259
template<class T_numtype1, int N_rank1, class P_expr2>
1260
inline
1261
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
1262
_bz_drem<T_numtype1,typename P_expr2::T_numtype> > >
1263
drem(const Array<T_numtype1, N_rank1>& d1, _bz_ArrayExpr<P_expr2> d2)
1264
{
1265
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
1266
_bz_drem<T_numtype1,typename P_expr2::T_numtype> >(d1.begin(), d2);
1267
}
1268
1269
template<class T_numtype1, int N_rank1, int N_index2>
1270
inline
1271
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
1272
_bz_drem<T_numtype1,int> > >
1273
drem(const Array<T_numtype1, N_rank1>& d1, IndexPlaceholder<N_index2> d2)
1274
{
1275
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
1276
_bz_drem<T_numtype1,int> >(d1.begin(), d2);
1277
}
1278
1279
template<class T_numtype1, int N_rank1>
1280
inline
1281
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
1282
_bz_drem<T_numtype1,float> > >
1283
drem(const Array<T_numtype1, N_rank1>& d1, float d2)
1284
{
1285
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
1286
_bz_drem<T_numtype1,float> >(d1.begin(), _bz_ArrayExprConstant<float>(d2));
1287
}
1288
1289
template<class T_numtype1, int N_rank1>
1290
inline
1291
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
1292
_bz_drem<T_numtype1,double> > >
1293
drem(const Array<T_numtype1, N_rank1>& d1, double d2)
1294
{
1295
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
1296
_bz_drem<T_numtype1,double> >(d1.begin(), _bz_ArrayExprConstant<double>(d2));
1297
}
1298
1299
template<class T_numtype1, int N_rank1>
1300
inline
1301
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
1302
_bz_drem<T_numtype1,long double> > >
1303
drem(const Array<T_numtype1, N_rank1>& d1, long double d2)
1304
{
1305
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
1306
_bz_drem<T_numtype1,long double> >(d1.begin(), _bz_ArrayExprConstant<long double>(d2));
1307
}
1308
1309
#ifdef BZ_HAVE_COMPLEX
1310
template<class T_numtype1, int N_rank1, class T2>
1311
inline
1312
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
1313
_bz_drem<T_numtype1,complex<T2> > > >
1314
drem(const Array<T_numtype1, N_rank1>& d1, complex<T2> d2)
1315
{
1316
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
1317
_bz_drem<T_numtype1,complex<T2> > >(d1.begin(), _bz_ArrayExprConstant<complex<T2> > (d2));
1318
}
1319
1320
#endif // BZ_HAVE_COMPLEX
1321
1322
template<class P_expr1, class T_numtype2, int N_rank2>
1323
inline
1324
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
1325
_bz_drem<typename P_expr1::T_numtype,T_numtype2> > >
1326
drem(_bz_ArrayExpr<P_expr1> d1, const Array<T_numtype2, N_rank2>& d2)
1327
{
1328
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
1329
_bz_drem<typename P_expr1::T_numtype,T_numtype2> >(d1, d2.begin());
1330
}
1331
1332
template<class P_expr1, class P_expr2>
1333
inline
1334
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
1335
_bz_drem<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
1336
drem(_bz_ArrayExpr<P_expr1> d1, _bz_ArrayExpr<P_expr2> d2)
1337
{
1338
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
1339
_bz_drem<typename P_expr1::T_numtype,typename P_expr2::T_numtype> >(d1, d2);
1340
}
1341
1342
template<class P_expr1, int N_index2>
1343
inline
1344
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
1345
_bz_drem<typename P_expr1::T_numtype,int> > >
1346
drem(_bz_ArrayExpr<P_expr1> d1, IndexPlaceholder<N_index2> d2)
1347
{
1348
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
1349
_bz_drem<typename P_expr1::T_numtype,int> >(d1, d2);
1350
}
1351
1352
template<class P_expr1>
1353
inline
1354
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
1355
_bz_drem<typename P_expr1::T_numtype,float> > >
1356
drem(_bz_ArrayExpr<P_expr1> d1, float d2)
1357
{
1358
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
1359
_bz_drem<typename P_expr1::T_numtype,float> >(d1, _bz_ArrayExprConstant<float>(d2));
1360
}
1361
1362
template<class P_expr1>
1363
inline
1364
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
1365
_bz_drem<typename P_expr1::T_numtype,double> > >
1366
drem(_bz_ArrayExpr<P_expr1> d1, double d2)
1367
{
1368
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
1369
_bz_drem<typename P_expr1::T_numtype,double> >(d1, _bz_ArrayExprConstant<double>(d2));
1370
}
1371
1372
template<class P_expr1>
1373
inline
1374
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
1375
_bz_drem<typename P_expr1::T_numtype,long double> > >
1376
drem(_bz_ArrayExpr<P_expr1> d1, long double d2)
1377
{
1378
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
1379
_bz_drem<typename P_expr1::T_numtype,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
1380
}
1381
1382
#ifdef BZ_HAVE_COMPLEX
1383
template<class P_expr1, class T2>
1384
inline
1385
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
1386
_bz_drem<typename P_expr1::T_numtype,complex<T2> > > >
1387
drem(_bz_ArrayExpr<P_expr1> d1, complex<T2> d2)
1388
{
1389
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
1390
_bz_drem<typename P_expr1::T_numtype,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
1391
}
1392
1393
#endif // BZ_HAVE_COMPLEX
1394
1395
template<int N_index1, class T_numtype2, int N_rank2>
1396
inline
1397
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
1398
_bz_drem<int,T_numtype2> > >
1399
drem(IndexPlaceholder<N_index1> d1, const Array<T_numtype2, N_rank2>& d2)
1400
{
1401
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
1402
_bz_drem<int,T_numtype2> >(d1, d2.begin());
1403
}
1404
1405
template<int N_index1, class P_expr2>
1406
inline
1407
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
1408
_bz_drem<int,typename P_expr2::T_numtype> > >
1409
drem(IndexPlaceholder<N_index1> d1, _bz_ArrayExpr<P_expr2> d2)
1410
{
1411
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
1412
_bz_drem<int,typename P_expr2::T_numtype> >(d1, d2);
1413
}
1414
1415
template<int N_index1, int N_index2>
1416
inline
1417
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
1418
_bz_drem<int,int> > >
1419
drem(IndexPlaceholder<N_index1> d1, IndexPlaceholder<N_index2> d2)
1420
{
1421
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
1422
_bz_drem<int,int> >(d1, d2);
1423
}
1424
1425
template<int N_index1>
1426
inline
1427
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
1428
_bz_drem<int,float> > >
1429
drem(IndexPlaceholder<N_index1> d1, float d2)
1430
{
1431
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
1432
_bz_drem<int,float> >(d1, _bz_ArrayExprConstant<float>(d2));
1433
}
1434
1435
template<int N_index1>
1436
inline
1437
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
1438
_bz_drem<int,double> > >
1439
drem(IndexPlaceholder<N_index1> d1, double d2)
1440
{
1441
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
1442
_bz_drem<int,double> >(d1, _bz_ArrayExprConstant<double>(d2));
1443
}
1444
1445
template<int N_index1>
1446
inline
1447
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
1448
_bz_drem<int,long double> > >
1449
drem(IndexPlaceholder<N_index1> d1, long double d2)
1450
{
1451
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
1452
_bz_drem<int,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
1453
}
1454
1455
#ifdef BZ_HAVE_COMPLEX
1456
template<int N_index1, class T2>
1457
inline
1458
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
1459
_bz_drem<int,complex<T2> > > >
1460
drem(IndexPlaceholder<N_index1> d1, complex<T2> d2)
1461
{
1462
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
1463
_bz_drem<int,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
1464
}
1465
1466
#endif // BZ_HAVE_COMPLEX
1467
1468
template<class T_numtype2, int N_rank2>
1469
inline
1470
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
1471
_bz_drem<float,T_numtype2> > >
1472
drem(float d1, const Array<T_numtype2, N_rank2>& d2)
1473
{
1474
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
1475
_bz_drem<float,T_numtype2> >(_bz_ArrayExprConstant<float>(d1), d2.begin());
1476
}
1477
1478
template<class P_expr2>
1479
inline
1480
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
1481
_bz_drem<float,typename P_expr2::T_numtype> > >
1482
drem(float d1, _bz_ArrayExpr<P_expr2> d2)
1483
{
1484
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
1485
_bz_drem<float,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<float>(d1), d2);
1486
}
1487
1488
template<int N_index2>
1489
inline
1490
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
1491
_bz_drem<float,int> > >
1492
drem(float d1, IndexPlaceholder<N_index2> d2)
1493
{
1494
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
1495
_bz_drem<float,int> >(_bz_ArrayExprConstant<float>(d1), d2);
1496
}
1497
1498
template<class T_numtype2, int N_rank2>
1499
inline
1500
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
1501
_bz_drem<double,T_numtype2> > >
1502
drem(double d1, const Array<T_numtype2, N_rank2>& d2)
1503
{
1504
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
1505
_bz_drem<double,T_numtype2> >(_bz_ArrayExprConstant<double>(d1), d2.begin());
1506
}
1507
1508
template<class P_expr2>
1509
inline
1510
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
1511
_bz_drem<double,typename P_expr2::T_numtype> > >
1512
drem(double d1, _bz_ArrayExpr<P_expr2> d2)
1513
{
1514
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
1515
_bz_drem<double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<double>(d1), d2);
1516
}
1517
1518
template<int N_index2>
1519
inline
1520
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
1521
_bz_drem<double,int> > >
1522
drem(double d1, IndexPlaceholder<N_index2> d2)
1523
{
1524
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
1525
_bz_drem<double,int> >(_bz_ArrayExprConstant<double>(d1), d2);
1526
}
1527
1528
template<class T_numtype2, int N_rank2>
1529
inline
1530
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
1531
_bz_drem<long double,T_numtype2> > >
1532
drem(long double d1, const Array<T_numtype2, N_rank2>& d2)
1533
{
1534
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
1535
_bz_drem<long double,T_numtype2> >(_bz_ArrayExprConstant<long double>(d1), d2.begin());
1536
}
1537
1538
template<class P_expr2>
1539
inline
1540
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
1541
_bz_drem<long double,typename P_expr2::T_numtype> > >
1542
drem(long double d1, _bz_ArrayExpr<P_expr2> d2)
1543
{
1544
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
1545
_bz_drem<long double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<long double>(d1), d2);
1546
}
1547
1548
template<int N_index2>
1549
inline
1550
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
1551
_bz_drem<long double,int> > >
1552
drem(long double d1, IndexPlaceholder<N_index2> d2)
1553
{
1554
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
1555
_bz_drem<long double,int> >(_bz_ArrayExprConstant<long double>(d1), d2);
1556
}
1557
1558
#ifdef BZ_HAVE_COMPLEX
1559
template<class T1, class T_numtype2, int N_rank2>
1560
inline
1561
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
1562
_bz_drem<complex<T1> ,T_numtype2> > >
1563
drem(complex<T1> d1, const Array<T_numtype2, N_rank2>& d2)
1564
{
1565
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
1566
_bz_drem<complex<T1> ,T_numtype2> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2.begin());
1567
}
1568
1569
#endif // BZ_HAVE_COMPLEX
1570
1571
#ifdef BZ_HAVE_COMPLEX
1572
template<class T1, class P_expr2>
1573
inline
1574
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
1575
_bz_drem<complex<T1> ,typename P_expr2::T_numtype> > >
1576
drem(complex<T1> d1, _bz_ArrayExpr<P_expr2> d2)
1577
{
1578
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
1579
_bz_drem<complex<T1> ,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
1580
}
1581
1582
#endif // BZ_HAVE_COMPLEX
1583
1584
#ifdef BZ_HAVE_COMPLEX
1585
template<class T1, int N_index2>
1586
inline
1587
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
1588
_bz_drem<complex<T1> ,int> > >
1589
drem(complex<T1> d1, IndexPlaceholder<N_index2> d2)
1590
{
1591
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
1592
_bz_drem<complex<T1> ,int> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
1593
}
1594
1595
#endif // BZ_HAVE_COMPLEX
1596
1597
#endif
1598
1599
/****************************************************************************
1600
* exp
1601
****************************************************************************/
1602
1603
template<class T_numtype1, int N_rank1>
1604
inline
1605
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1606
_bz_exp<T_numtype1> > >
1607
exp(const Array<T_numtype1, N_rank1>& d1)
1608
{
1609
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1610
_bz_exp<T_numtype1> >(d1.begin());
1611
}
1612
1613
template<class P_expr1>
1614
inline
1615
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1616
_bz_exp<typename P_expr1::T_numtype> > >
1617
exp(_bz_ArrayExpr<P_expr1> d1)
1618
{
1619
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1620
_bz_exp<typename P_expr1::T_numtype> >(d1);
1621
}
1622
1623
template<int N_index1>
1624
inline
1625
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1626
_bz_exp<int> > >
1627
exp(IndexPlaceholder<N_index1> d1)
1628
{
1629
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1630
_bz_exp<int> >(d1);
1631
}
1632
1633
1634
/****************************************************************************
1635
* expm1
1636
****************************************************************************/
1637
1638
#ifdef BZ_HAVE_IEEE_MATH
1639
template<class T_numtype1, int N_rank1>
1640
inline
1641
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1642
_bz_expm1<T_numtype1> > >
1643
expm1(const Array<T_numtype1, N_rank1>& d1)
1644
{
1645
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1646
_bz_expm1<T_numtype1> >(d1.begin());
1647
}
1648
1649
template<class P_expr1>
1650
inline
1651
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1652
_bz_expm1<typename P_expr1::T_numtype> > >
1653
expm1(_bz_ArrayExpr<P_expr1> d1)
1654
{
1655
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1656
_bz_expm1<typename P_expr1::T_numtype> >(d1);
1657
}
1658
1659
template<int N_index1>
1660
inline
1661
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1662
_bz_expm1<int> > >
1663
expm1(IndexPlaceholder<N_index1> d1)
1664
{
1665
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1666
_bz_expm1<int> >(d1);
1667
}
1668
1669
#endif
1670
1671
/****************************************************************************
1672
* erf
1673
****************************************************************************/
1674
1675
#ifdef BZ_HAVE_IEEE_MATH
1676
template<class T_numtype1, int N_rank1>
1677
inline
1678
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1679
_bz_erf<T_numtype1> > >
1680
erf(const Array<T_numtype1, N_rank1>& d1)
1681
{
1682
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1683
_bz_erf<T_numtype1> >(d1.begin());
1684
}
1685
1686
template<class P_expr1>
1687
inline
1688
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1689
_bz_erf<typename P_expr1::T_numtype> > >
1690
erf(_bz_ArrayExpr<P_expr1> d1)
1691
{
1692
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1693
_bz_erf<typename P_expr1::T_numtype> >(d1);
1694
}
1695
1696
template<int N_index1>
1697
inline
1698
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1699
_bz_erf<int> > >
1700
erf(IndexPlaceholder<N_index1> d1)
1701
{
1702
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1703
_bz_erf<int> >(d1);
1704
}
1705
1706
#endif
1707
1708
/****************************************************************************
1709
* erfc
1710
****************************************************************************/
1711
1712
#ifdef BZ_HAVE_IEEE_MATH
1713
template<class T_numtype1, int N_rank1>
1714
inline
1715
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1716
_bz_erfc<T_numtype1> > >
1717
erfc(const Array<T_numtype1, N_rank1>& d1)
1718
{
1719
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1720
_bz_erfc<T_numtype1> >(d1.begin());
1721
}
1722
1723
template<class P_expr1>
1724
inline
1725
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1726
_bz_erfc<typename P_expr1::T_numtype> > >
1727
erfc(_bz_ArrayExpr<P_expr1> d1)
1728
{
1729
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1730
_bz_erfc<typename P_expr1::T_numtype> >(d1);
1731
}
1732
1733
template<int N_index1>
1734
inline
1735
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1736
_bz_erfc<int> > >
1737
erfc(IndexPlaceholder<N_index1> d1)
1738
{
1739
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1740
_bz_erfc<int> >(d1);
1741
}
1742
1743
#endif
1744
1745
/****************************************************************************
1746
* fabs
1747
****************************************************************************/
1748
1749
template<class T_numtype1, int N_rank1>
1750
inline
1751
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1752
_bz_abs<T_numtype1> > >
1753
fabs(const Array<T_numtype1, N_rank1>& d1)
1754
{
1755
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1756
_bz_abs<T_numtype1> >(d1.begin());
1757
}
1758
1759
template<class P_expr1>
1760
inline
1761
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1762
_bz_abs<typename P_expr1::T_numtype> > >
1763
fabs(_bz_ArrayExpr<P_expr1> d1)
1764
{
1765
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1766
_bz_abs<typename P_expr1::T_numtype> >(d1);
1767
}
1768
1769
template<int N_index1>
1770
inline
1771
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1772
_bz_abs<int> > >
1773
fabs(IndexPlaceholder<N_index1> d1)
1774
{
1775
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1776
_bz_abs<int> >(d1);
1777
}
1778
1779
1780
/****************************************************************************
1781
* floor
1782
****************************************************************************/
1783
1784
template<class T_numtype1, int N_rank1>
1785
inline
1786
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1787
_bz_floor<T_numtype1> > >
1788
floor(const Array<T_numtype1, N_rank1>& d1)
1789
{
1790
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
1791
_bz_floor<T_numtype1> >(d1.begin());
1792
}
1793
1794
template<class P_expr1>
1795
inline
1796
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1797
_bz_floor<typename P_expr1::T_numtype> > >
1798
floor(_bz_ArrayExpr<P_expr1> d1)
1799
{
1800
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
1801
_bz_floor<typename P_expr1::T_numtype> >(d1);
1802
}
1803
1804
template<int N_index1>
1805
inline
1806
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1807
_bz_floor<int> > >
1808
floor(IndexPlaceholder<N_index1> d1)
1809
{
1810
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
1811
_bz_floor<int> >(d1);
1812
}
1813
1814
1815
/****************************************************************************
1816
* fmod
1817
****************************************************************************/
1818
1819
#ifdef BZ_HAVE_SYSTEM_V_MATH
1820
template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>
1821
inline
1822
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
1823
_bz_fmod<T_numtype1,T_numtype2> > >
1824
fmod(const Array<T_numtype1, N_rank1>& d1, const Array<T_numtype2, N_rank2>& d2)
1825
{
1826
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
1827
_bz_fmod<T_numtype1,T_numtype2> >(d1.begin(), d2.begin());
1828
}
1829
1830
template<class T_numtype1, int N_rank1, class P_expr2>
1831
inline
1832
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
1833
_bz_fmod<T_numtype1,typename P_expr2::T_numtype> > >
1834
fmod(const Array<T_numtype1, N_rank1>& d1, _bz_ArrayExpr<P_expr2> d2)
1835
{
1836
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
1837
_bz_fmod<T_numtype1,typename P_expr2::T_numtype> >(d1.begin(), d2);
1838
}
1839
1840
template<class T_numtype1, int N_rank1, int N_index2>
1841
inline
1842
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
1843
_bz_fmod<T_numtype1,int> > >
1844
fmod(const Array<T_numtype1, N_rank1>& d1, IndexPlaceholder<N_index2> d2)
1845
{
1846
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
1847
_bz_fmod<T_numtype1,int> >(d1.begin(), d2);
1848
}
1849
1850
template<class T_numtype1, int N_rank1>
1851
inline
1852
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
1853
_bz_fmod<T_numtype1,float> > >
1854
fmod(const Array<T_numtype1, N_rank1>& d1, float d2)
1855
{
1856
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
1857
_bz_fmod<T_numtype1,float> >(d1.begin(), _bz_ArrayExprConstant<float>(d2));
1858
}
1859
1860
template<class T_numtype1, int N_rank1>
1861
inline
1862
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
1863
_bz_fmod<T_numtype1,double> > >
1864
fmod(const Array<T_numtype1, N_rank1>& d1, double d2)
1865
{
1866
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
1867
_bz_fmod<T_numtype1,double> >(d1.begin(), _bz_ArrayExprConstant<double>(d2));
1868
}
1869
1870
template<class T_numtype1, int N_rank1>
1871
inline
1872
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
1873
_bz_fmod<T_numtype1,long double> > >
1874
fmod(const Array<T_numtype1, N_rank1>& d1, long double d2)
1875
{
1876
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
1877
_bz_fmod<T_numtype1,long double> >(d1.begin(), _bz_ArrayExprConstant<long double>(d2));
1878
}
1879
1880
#ifdef BZ_HAVE_COMPLEX
1881
template<class T_numtype1, int N_rank1, class T2>
1882
inline
1883
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
1884
_bz_fmod<T_numtype1,complex<T2> > > >
1885
fmod(const Array<T_numtype1, N_rank1>& d1, complex<T2> d2)
1886
{
1887
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
1888
_bz_fmod<T_numtype1,complex<T2> > >(d1.begin(), _bz_ArrayExprConstant<complex<T2> > (d2));
1889
}
1890
1891
#endif // BZ_HAVE_COMPLEX
1892
1893
template<class P_expr1, class T_numtype2, int N_rank2>
1894
inline
1895
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
1896
_bz_fmod<typename P_expr1::T_numtype,T_numtype2> > >
1897
fmod(_bz_ArrayExpr<P_expr1> d1, const Array<T_numtype2, N_rank2>& d2)
1898
{
1899
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
1900
_bz_fmod<typename P_expr1::T_numtype,T_numtype2> >(d1, d2.begin());
1901
}
1902
1903
template<class P_expr1, class P_expr2>
1904
inline
1905
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
1906
_bz_fmod<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
1907
fmod(_bz_ArrayExpr<P_expr1> d1, _bz_ArrayExpr<P_expr2> d2)
1908
{
1909
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
1910
_bz_fmod<typename P_expr1::T_numtype,typename P_expr2::T_numtype> >(d1, d2);
1911
}
1912
1913
template<class P_expr1, int N_index2>
1914
inline
1915
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
1916
_bz_fmod<typename P_expr1::T_numtype,int> > >
1917
fmod(_bz_ArrayExpr<P_expr1> d1, IndexPlaceholder<N_index2> d2)
1918
{
1919
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
1920
_bz_fmod<typename P_expr1::T_numtype,int> >(d1, d2);
1921
}
1922
1923
template<class P_expr1>
1924
inline
1925
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
1926
_bz_fmod<typename P_expr1::T_numtype,float> > >
1927
fmod(_bz_ArrayExpr<P_expr1> d1, float d2)
1928
{
1929
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
1930
_bz_fmod<typename P_expr1::T_numtype,float> >(d1, _bz_ArrayExprConstant<float>(d2));
1931
}
1932
1933
template<class P_expr1>
1934
inline
1935
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
1936
_bz_fmod<typename P_expr1::T_numtype,double> > >
1937
fmod(_bz_ArrayExpr<P_expr1> d1, double d2)
1938
{
1939
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
1940
_bz_fmod<typename P_expr1::T_numtype,double> >(d1, _bz_ArrayExprConstant<double>(d2));
1941
}
1942
1943
template<class P_expr1>
1944
inline
1945
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
1946
_bz_fmod<typename P_expr1::T_numtype,long double> > >
1947
fmod(_bz_ArrayExpr<P_expr1> d1, long double d2)
1948
{
1949
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
1950
_bz_fmod<typename P_expr1::T_numtype,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
1951
}
1952
1953
#ifdef BZ_HAVE_COMPLEX
1954
template<class P_expr1, class T2>
1955
inline
1956
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
1957
_bz_fmod<typename P_expr1::T_numtype,complex<T2> > > >
1958
fmod(_bz_ArrayExpr<P_expr1> d1, complex<T2> d2)
1959
{
1960
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
1961
_bz_fmod<typename P_expr1::T_numtype,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
1962
}
1963
1964
#endif // BZ_HAVE_COMPLEX
1965
1966
template<int N_index1, class T_numtype2, int N_rank2>
1967
inline
1968
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
1969
_bz_fmod<int,T_numtype2> > >
1970
fmod(IndexPlaceholder<N_index1> d1, const Array<T_numtype2, N_rank2>& d2)
1971
{
1972
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
1973
_bz_fmod<int,T_numtype2> >(d1, d2.begin());
1974
}
1975
1976
template<int N_index1, class P_expr2>
1977
inline
1978
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
1979
_bz_fmod<int,typename P_expr2::T_numtype> > >
1980
fmod(IndexPlaceholder<N_index1> d1, _bz_ArrayExpr<P_expr2> d2)
1981
{
1982
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
1983
_bz_fmod<int,typename P_expr2::T_numtype> >(d1, d2);
1984
}
1985
1986
template<int N_index1, int N_index2>
1987
inline
1988
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
1989
_bz_fmod<int,int> > >
1990
fmod(IndexPlaceholder<N_index1> d1, IndexPlaceholder<N_index2> d2)
1991
{
1992
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
1993
_bz_fmod<int,int> >(d1, d2);
1994
}
1995
1996
template<int N_index1>
1997
inline
1998
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
1999
_bz_fmod<int,float> > >
2000
fmod(IndexPlaceholder<N_index1> d1, float d2)
2001
{
2002
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
2003
_bz_fmod<int,float> >(d1, _bz_ArrayExprConstant<float>(d2));
2004
}
2005
2006
template<int N_index1>
2007
inline
2008
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
2009
_bz_fmod<int,double> > >
2010
fmod(IndexPlaceholder<N_index1> d1, double d2)
2011
{
2012
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
2013
_bz_fmod<int,double> >(d1, _bz_ArrayExprConstant<double>(d2));
2014
}
2015
2016
template<int N_index1>
2017
inline
2018
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
2019
_bz_fmod<int,long double> > >
2020
fmod(IndexPlaceholder<N_index1> d1, long double d2)
2021
{
2022
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
2023
_bz_fmod<int,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
2024
}
2025
2026
#ifdef BZ_HAVE_COMPLEX
2027
template<int N_index1, class T2>
2028
inline
2029
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
2030
_bz_fmod<int,complex<T2> > > >
2031
fmod(IndexPlaceholder<N_index1> d1, complex<T2> d2)
2032
{
2033
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
2034
_bz_fmod<int,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
2035
}
2036
2037
#endif // BZ_HAVE_COMPLEX
2038
2039
template<class T_numtype2, int N_rank2>
2040
inline
2041
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
2042
_bz_fmod<float,T_numtype2> > >
2043
fmod(float d1, const Array<T_numtype2, N_rank2>& d2)
2044
{
2045
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
2046
_bz_fmod<float,T_numtype2> >(_bz_ArrayExprConstant<float>(d1), d2.begin());
2047
}
2048
2049
template<class P_expr2>
2050
inline
2051
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
2052
_bz_fmod<float,typename P_expr2::T_numtype> > >
2053
fmod(float d1, _bz_ArrayExpr<P_expr2> d2)
2054
{
2055
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
2056
_bz_fmod<float,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<float>(d1), d2);
2057
}
2058
2059
template<int N_index2>
2060
inline
2061
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
2062
_bz_fmod<float,int> > >
2063
fmod(float d1, IndexPlaceholder<N_index2> d2)
2064
{
2065
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
2066
_bz_fmod<float,int> >(_bz_ArrayExprConstant<float>(d1), d2);
2067
}
2068
2069
template<class T_numtype2, int N_rank2>
2070
inline
2071
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
2072
_bz_fmod<double,T_numtype2> > >
2073
fmod(double d1, const Array<T_numtype2, N_rank2>& d2)
2074
{
2075
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
2076
_bz_fmod<double,T_numtype2> >(_bz_ArrayExprConstant<double>(d1), d2.begin());
2077
}
2078
2079
template<class P_expr2>
2080
inline
2081
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
2082
_bz_fmod<double,typename P_expr2::T_numtype> > >
2083
fmod(double d1, _bz_ArrayExpr<P_expr2> d2)
2084
{
2085
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
2086
_bz_fmod<double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<double>(d1), d2);
2087
}
2088
2089
template<int N_index2>
2090
inline
2091
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
2092
_bz_fmod<double,int> > >
2093
fmod(double d1, IndexPlaceholder<N_index2> d2)
2094
{
2095
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
2096
_bz_fmod<double,int> >(_bz_ArrayExprConstant<double>(d1), d2);
2097
}
2098
2099
template<class T_numtype2, int N_rank2>
2100
inline
2101
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
2102
_bz_fmod<long double,T_numtype2> > >
2103
fmod(long double d1, const Array<T_numtype2, N_rank2>& d2)
2104
{
2105
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
2106
_bz_fmod<long double,T_numtype2> >(_bz_ArrayExprConstant<long double>(d1), d2.begin());
2107
}
2108
2109
template<class P_expr2>
2110
inline
2111
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
2112
_bz_fmod<long double,typename P_expr2::T_numtype> > >
2113
fmod(long double d1, _bz_ArrayExpr<P_expr2> d2)
2114
{
2115
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
2116
_bz_fmod<long double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<long double>(d1), d2);
2117
}
2118
2119
template<int N_index2>
2120
inline
2121
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
2122
_bz_fmod<long double,int> > >
2123
fmod(long double d1, IndexPlaceholder<N_index2> d2)
2124
{
2125
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
2126
_bz_fmod<long double,int> >(_bz_ArrayExprConstant<long double>(d1), d2);
2127
}
2128
2129
#ifdef BZ_HAVE_COMPLEX
2130
template<class T1, class T_numtype2, int N_rank2>
2131
inline
2132
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
2133
_bz_fmod<complex<T1> ,T_numtype2> > >
2134
fmod(complex<T1> d1, const Array<T_numtype2, N_rank2>& d2)
2135
{
2136
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
2137
_bz_fmod<complex<T1> ,T_numtype2> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2.begin());
2138
}
2139
2140
#endif // BZ_HAVE_COMPLEX
2141
2142
#ifdef BZ_HAVE_COMPLEX
2143
template<class T1, class P_expr2>
2144
inline
2145
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
2146
_bz_fmod<complex<T1> ,typename P_expr2::T_numtype> > >
2147
fmod(complex<T1> d1, _bz_ArrayExpr<P_expr2> d2)
2148
{
2149
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
2150
_bz_fmod<complex<T1> ,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
2151
}
2152
2153
#endif // BZ_HAVE_COMPLEX
2154
2155
#ifdef BZ_HAVE_COMPLEX
2156
template<class T1, int N_index2>
2157
inline
2158
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
2159
_bz_fmod<complex<T1> ,int> > >
2160
fmod(complex<T1> d1, IndexPlaceholder<N_index2> d2)
2161
{
2162
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
2163
_bz_fmod<complex<T1> ,int> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
2164
}
2165
2166
#endif // BZ_HAVE_COMPLEX
2167
2168
#endif
2169
2170
/****************************************************************************
2171
* hypot
2172
****************************************************************************/
2173
2174
#ifdef BZ_HAVE_SYSTEM_V_MATH
2175
template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>
2176
inline
2177
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
2178
_bz_hypot<T_numtype1,T_numtype2> > >
2179
hypot(const Array<T_numtype1, N_rank1>& d1, const Array<T_numtype2, N_rank2>& d2)
2180
{
2181
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
2182
_bz_hypot<T_numtype1,T_numtype2> >(d1.begin(), d2.begin());
2183
}
2184
2185
template<class T_numtype1, int N_rank1, class P_expr2>
2186
inline
2187
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
2188
_bz_hypot<T_numtype1,typename P_expr2::T_numtype> > >
2189
hypot(const Array<T_numtype1, N_rank1>& d1, _bz_ArrayExpr<P_expr2> d2)
2190
{
2191
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
2192
_bz_hypot<T_numtype1,typename P_expr2::T_numtype> >(d1.begin(), d2);
2193
}
2194
2195
template<class T_numtype1, int N_rank1, int N_index2>
2196
inline
2197
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
2198
_bz_hypot<T_numtype1,int> > >
2199
hypot(const Array<T_numtype1, N_rank1>& d1, IndexPlaceholder<N_index2> d2)
2200
{
2201
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
2202
_bz_hypot<T_numtype1,int> >(d1.begin(), d2);
2203
}
2204
2205
template<class T_numtype1, int N_rank1>
2206
inline
2207
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
2208
_bz_hypot<T_numtype1,float> > >
2209
hypot(const Array<T_numtype1, N_rank1>& d1, float d2)
2210
{
2211
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
2212
_bz_hypot<T_numtype1,float> >(d1.begin(), _bz_ArrayExprConstant<float>(d2));
2213
}
2214
2215
template<class T_numtype1, int N_rank1>
2216
inline
2217
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
2218
_bz_hypot<T_numtype1,double> > >
2219
hypot(const Array<T_numtype1, N_rank1>& d1, double d2)
2220
{
2221
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
2222
_bz_hypot<T_numtype1,double> >(d1.begin(), _bz_ArrayExprConstant<double>(d2));
2223
}
2224
2225
template<class T_numtype1, int N_rank1>
2226
inline
2227
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
2228
_bz_hypot<T_numtype1,long double> > >
2229
hypot(const Array<T_numtype1, N_rank1>& d1, long double d2)
2230
{
2231
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
2232
_bz_hypot<T_numtype1,long double> >(d1.begin(), _bz_ArrayExprConstant<long double>(d2));
2233
}
2234
2235
#ifdef BZ_HAVE_COMPLEX
2236
template<class T_numtype1, int N_rank1, class T2>
2237
inline
2238
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
2239
_bz_hypot<T_numtype1,complex<T2> > > >
2240
hypot(const Array<T_numtype1, N_rank1>& d1, complex<T2> d2)
2241
{
2242
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
2243
_bz_hypot<T_numtype1,complex<T2> > >(d1.begin(), _bz_ArrayExprConstant<complex<T2> > (d2));
2244
}
2245
2246
#endif // BZ_HAVE_COMPLEX
2247
2248
template<class P_expr1, class T_numtype2, int N_rank2>
2249
inline
2250
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
2251
_bz_hypot<typename P_expr1::T_numtype,T_numtype2> > >
2252
hypot(_bz_ArrayExpr<P_expr1> d1, const Array<T_numtype2, N_rank2>& d2)
2253
{
2254
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
2255
_bz_hypot<typename P_expr1::T_numtype,T_numtype2> >(d1, d2.begin());
2256
}
2257
2258
template<class P_expr1, class P_expr2>
2259
inline
2260
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
2261
_bz_hypot<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
2262
hypot(_bz_ArrayExpr<P_expr1> d1, _bz_ArrayExpr<P_expr2> d2)
2263
{
2264
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
2265
_bz_hypot<typename P_expr1::T_numtype,typename P_expr2::T_numtype> >(d1, d2);
2266
}
2267
2268
template<class P_expr1, int N_index2>
2269
inline
2270
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
2271
_bz_hypot<typename P_expr1::T_numtype,int> > >
2272
hypot(_bz_ArrayExpr<P_expr1> d1, IndexPlaceholder<N_index2> d2)
2273
{
2274
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
2275
_bz_hypot<typename P_expr1::T_numtype,int> >(d1, d2);
2276
}
2277
2278
template<class P_expr1>
2279
inline
2280
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
2281
_bz_hypot<typename P_expr1::T_numtype,float> > >
2282
hypot(_bz_ArrayExpr<P_expr1> d1, float d2)
2283
{
2284
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
2285
_bz_hypot<typename P_expr1::T_numtype,float> >(d1, _bz_ArrayExprConstant<float>(d2));
2286
}
2287
2288
template<class P_expr1>
2289
inline
2290
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
2291
_bz_hypot<typename P_expr1::T_numtype,double> > >
2292
hypot(_bz_ArrayExpr<P_expr1> d1, double d2)
2293
{
2294
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
2295
_bz_hypot<typename P_expr1::T_numtype,double> >(d1, _bz_ArrayExprConstant<double>(d2));
2296
}
2297
2298
template<class P_expr1>
2299
inline
2300
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
2301
_bz_hypot<typename P_expr1::T_numtype,long double> > >
2302
hypot(_bz_ArrayExpr<P_expr1> d1, long double d2)
2303
{
2304
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
2305
_bz_hypot<typename P_expr1::T_numtype,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
2306
}
2307
2308
#ifdef BZ_HAVE_COMPLEX
2309
template<class P_expr1, class T2>
2310
inline
2311
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
2312
_bz_hypot<typename P_expr1::T_numtype,complex<T2> > > >
2313
hypot(_bz_ArrayExpr<P_expr1> d1, complex<T2> d2)
2314
{
2315
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
2316
_bz_hypot<typename P_expr1::T_numtype,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
2317
}
2318
2319
#endif // BZ_HAVE_COMPLEX
2320
2321
template<int N_index1, class T_numtype2, int N_rank2>
2322
inline
2323
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
2324
_bz_hypot<int,T_numtype2> > >
2325
hypot(IndexPlaceholder<N_index1> d1, const Array<T_numtype2, N_rank2>& d2)
2326
{
2327
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
2328
_bz_hypot<int,T_numtype2> >(d1, d2.begin());
2329
}
2330
2331
template<int N_index1, class P_expr2>
2332
inline
2333
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
2334
_bz_hypot<int,typename P_expr2::T_numtype> > >
2335
hypot(IndexPlaceholder<N_index1> d1, _bz_ArrayExpr<P_expr2> d2)
2336
{
2337
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
2338
_bz_hypot<int,typename P_expr2::T_numtype> >(d1, d2);
2339
}
2340
2341
template<int N_index1, int N_index2>
2342
inline
2343
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
2344
_bz_hypot<int,int> > >
2345
hypot(IndexPlaceholder<N_index1> d1, IndexPlaceholder<N_index2> d2)
2346
{
2347
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
2348
_bz_hypot<int,int> >(d1, d2);
2349
}
2350
2351
template<int N_index1>
2352
inline
2353
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
2354
_bz_hypot<int,float> > >
2355
hypot(IndexPlaceholder<N_index1> d1, float d2)
2356
{
2357
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
2358
_bz_hypot<int,float> >(d1, _bz_ArrayExprConstant<float>(d2));
2359
}
2360
2361
template<int N_index1>
2362
inline
2363
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
2364
_bz_hypot<int,double> > >
2365
hypot(IndexPlaceholder<N_index1> d1, double d2)
2366
{
2367
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
2368
_bz_hypot<int,double> >(d1, _bz_ArrayExprConstant<double>(d2));
2369
}
2370
2371
template<int N_index1>
2372
inline
2373
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
2374
_bz_hypot<int,long double> > >
2375
hypot(IndexPlaceholder<N_index1> d1, long double d2)
2376
{
2377
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
2378
_bz_hypot<int,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
2379
}
2380
2381
#ifdef BZ_HAVE_COMPLEX
2382
template<int N_index1, class T2>
2383
inline
2384
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
2385
_bz_hypot<int,complex<T2> > > >
2386
hypot(IndexPlaceholder<N_index1> d1, complex<T2> d2)
2387
{
2388
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
2389
_bz_hypot<int,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
2390
}
2391
2392
#endif // BZ_HAVE_COMPLEX
2393
2394
template<class T_numtype2, int N_rank2>
2395
inline
2396
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
2397
_bz_hypot<float,T_numtype2> > >
2398
hypot(float d1, const Array<T_numtype2, N_rank2>& d2)
2399
{
2400
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
2401
_bz_hypot<float,T_numtype2> >(_bz_ArrayExprConstant<float>(d1), d2.begin());
2402
}
2403
2404
template<class P_expr2>
2405
inline
2406
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
2407
_bz_hypot<float,typename P_expr2::T_numtype> > >
2408
hypot(float d1, _bz_ArrayExpr<P_expr2> d2)
2409
{
2410
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
2411
_bz_hypot<float,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<float>(d1), d2);
2412
}
2413
2414
template<int N_index2>
2415
inline
2416
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
2417
_bz_hypot<float,int> > >
2418
hypot(float d1, IndexPlaceholder<N_index2> d2)
2419
{
2420
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
2421
_bz_hypot<float,int> >(_bz_ArrayExprConstant<float>(d1), d2);
2422
}
2423
2424
template<class T_numtype2, int N_rank2>
2425
inline
2426
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
2427
_bz_hypot<double,T_numtype2> > >
2428
hypot(double d1, const Array<T_numtype2, N_rank2>& d2)
2429
{
2430
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
2431
_bz_hypot<double,T_numtype2> >(_bz_ArrayExprConstant<double>(d1), d2.begin());
2432
}
2433
2434
template<class P_expr2>
2435
inline
2436
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
2437
_bz_hypot<double,typename P_expr2::T_numtype> > >
2438
hypot(double d1, _bz_ArrayExpr<P_expr2> d2)
2439
{
2440
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
2441
_bz_hypot<double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<double>(d1), d2);
2442
}
2443
2444
template<int N_index2>
2445
inline
2446
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
2447
_bz_hypot<double,int> > >
2448
hypot(double d1, IndexPlaceholder<N_index2> d2)
2449
{
2450
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
2451
_bz_hypot<double,int> >(_bz_ArrayExprConstant<double>(d1), d2);
2452
}
2453
2454
template<class T_numtype2, int N_rank2>
2455
inline
2456
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
2457
_bz_hypot<long double,T_numtype2> > >
2458
hypot(long double d1, const Array<T_numtype2, N_rank2>& d2)
2459
{
2460
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
2461
_bz_hypot<long double,T_numtype2> >(_bz_ArrayExprConstant<long double>(d1), d2.begin());
2462
}
2463
2464
template<class P_expr2>
2465
inline
2466
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
2467
_bz_hypot<long double,typename P_expr2::T_numtype> > >
2468
hypot(long double d1, _bz_ArrayExpr<P_expr2> d2)
2469
{
2470
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
2471
_bz_hypot<long double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<long double>(d1), d2);
2472
}
2473
2474
template<int N_index2>
2475
inline
2476
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
2477
_bz_hypot<long double,int> > >
2478
hypot(long double d1, IndexPlaceholder<N_index2> d2)
2479
{
2480
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
2481
_bz_hypot<long double,int> >(_bz_ArrayExprConstant<long double>(d1), d2);
2482
}
2483
2484
#ifdef BZ_HAVE_COMPLEX
2485
template<class T1, class T_numtype2, int N_rank2>
2486
inline
2487
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
2488
_bz_hypot<complex<T1> ,T_numtype2> > >
2489
hypot(complex<T1> d1, const Array<T_numtype2, N_rank2>& d2)
2490
{
2491
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
2492
_bz_hypot<complex<T1> ,T_numtype2> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2.begin());
2493
}
2494
2495
#endif // BZ_HAVE_COMPLEX
2496
2497
#ifdef BZ_HAVE_COMPLEX
2498
template<class T1, class P_expr2>
2499
inline
2500
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
2501
_bz_hypot<complex<T1> ,typename P_expr2::T_numtype> > >
2502
hypot(complex<T1> d1, _bz_ArrayExpr<P_expr2> d2)
2503
{
2504
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
2505
_bz_hypot<complex<T1> ,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
2506
}
2507
2508
#endif // BZ_HAVE_COMPLEX
2509
2510
#ifdef BZ_HAVE_COMPLEX
2511
template<class T1, int N_index2>
2512
inline
2513
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
2514
_bz_hypot<complex<T1> ,int> > >
2515
hypot(complex<T1> d1, IndexPlaceholder<N_index2> d2)
2516
{
2517
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
2518
_bz_hypot<complex<T1> ,int> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
2519
}
2520
2521
#endif // BZ_HAVE_COMPLEX
2522
2523
#endif
2524
2525
/****************************************************************************
2526
* ilogb
2527
****************************************************************************/
2528
2529
#ifdef BZ_HAVE_SYSTEM_V_MATH
2530
template<class T_numtype1, int N_rank1>
2531
inline
2532
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2533
_bz_ilogb<T_numtype1> > >
2534
ilogb(const Array<T_numtype1, N_rank1>& d1)
2535
{
2536
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2537
_bz_ilogb<T_numtype1> >(d1.begin());
2538
}
2539
2540
template<class P_expr1>
2541
inline
2542
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2543
_bz_ilogb<typename P_expr1::T_numtype> > >
2544
ilogb(_bz_ArrayExpr<P_expr1> d1)
2545
{
2546
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2547
_bz_ilogb<typename P_expr1::T_numtype> >(d1);
2548
}
2549
2550
template<int N_index1>
2551
inline
2552
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2553
_bz_ilogb<int> > >
2554
ilogb(IndexPlaceholder<N_index1> d1)
2555
{
2556
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2557
_bz_ilogb<int> >(d1);
2558
}
2559
2560
#endif
2561
2562
/****************************************************************************
2563
* isnan
2564
****************************************************************************/
2565
2566
#ifdef BZ_HAVE_IEEE_MATH
2567
template<class T_numtype1, int N_rank1>
2568
inline
2569
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2570
_bz_isnan<T_numtype1> > >
2571
isnan(const Array<T_numtype1, N_rank1>& d1)
2572
{
2573
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2574
_bz_isnan<T_numtype1> >(d1.begin());
2575
}
2576
2577
template<class P_expr1>
2578
inline
2579
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2580
_bz_isnan<typename P_expr1::T_numtype> > >
2581
isnan(_bz_ArrayExpr<P_expr1> d1)
2582
{
2583
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2584
_bz_isnan<typename P_expr1::T_numtype> >(d1);
2585
}
2586
2587
template<int N_index1>
2588
inline
2589
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2590
_bz_isnan<int> > >
2591
isnan(IndexPlaceholder<N_index1> d1)
2592
{
2593
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2594
_bz_isnan<int> >(d1);
2595
}
2596
2597
#endif
2598
2599
/****************************************************************************
2600
* itrunc
2601
****************************************************************************/
2602
2603
#ifdef BZ_HAVE_SYSTEM_V_MATH
2604
template<class T_numtype1, int N_rank1>
2605
inline
2606
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2607
_bz_itrunc<T_numtype1> > >
2608
itrunc(const Array<T_numtype1, N_rank1>& d1)
2609
{
2610
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2611
_bz_itrunc<T_numtype1> >(d1.begin());
2612
}
2613
2614
template<class P_expr1>
2615
inline
2616
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2617
_bz_itrunc<typename P_expr1::T_numtype> > >
2618
itrunc(_bz_ArrayExpr<P_expr1> d1)
2619
{
2620
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2621
_bz_itrunc<typename P_expr1::T_numtype> >(d1);
2622
}
2623
2624
template<int N_index1>
2625
inline
2626
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2627
_bz_itrunc<int> > >
2628
itrunc(IndexPlaceholder<N_index1> d1)
2629
{
2630
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2631
_bz_itrunc<int> >(d1);
2632
}
2633
2634
#endif
2635
2636
/****************************************************************************
2637
* j0
2638
****************************************************************************/
2639
2640
#ifdef BZ_HAVE_IEEE_MATH
2641
template<class T_numtype1, int N_rank1>
2642
inline
2643
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2644
_bz_j0<T_numtype1> > >
2645
j0(const Array<T_numtype1, N_rank1>& d1)
2646
{
2647
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2648
_bz_j0<T_numtype1> >(d1.begin());
2649
}
2650
2651
template<class P_expr1>
2652
inline
2653
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2654
_bz_j0<typename P_expr1::T_numtype> > >
2655
j0(_bz_ArrayExpr<P_expr1> d1)
2656
{
2657
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2658
_bz_j0<typename P_expr1::T_numtype> >(d1);
2659
}
2660
2661
template<int N_index1>
2662
inline
2663
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2664
_bz_j0<int> > >
2665
j0(IndexPlaceholder<N_index1> d1)
2666
{
2667
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2668
_bz_j0<int> >(d1);
2669
}
2670
2671
#endif
2672
2673
/****************************************************************************
2674
* j1
2675
****************************************************************************/
2676
2677
#ifdef BZ_HAVE_IEEE_MATH
2678
template<class T_numtype1, int N_rank1>
2679
inline
2680
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2681
_bz_j1<T_numtype1> > >
2682
j1(const Array<T_numtype1, N_rank1>& d1)
2683
{
2684
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2685
_bz_j1<T_numtype1> >(d1.begin());
2686
}
2687
2688
template<class P_expr1>
2689
inline
2690
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2691
_bz_j1<typename P_expr1::T_numtype> > >
2692
j1(_bz_ArrayExpr<P_expr1> d1)
2693
{
2694
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2695
_bz_j1<typename P_expr1::T_numtype> >(d1);
2696
}
2697
2698
template<int N_index1>
2699
inline
2700
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2701
_bz_j1<int> > >
2702
j1(IndexPlaceholder<N_index1> d1)
2703
{
2704
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2705
_bz_j1<int> >(d1);
2706
}
2707
2708
#endif
2709
2710
/****************************************************************************
2711
* lgamma
2712
****************************************************************************/
2713
2714
#ifdef BZ_HAVE_IEEE_MATH
2715
template<class T_numtype1, int N_rank1>
2716
inline
2717
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2718
_bz_lgamma<T_numtype1> > >
2719
lgamma(const Array<T_numtype1, N_rank1>& d1)
2720
{
2721
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2722
_bz_lgamma<T_numtype1> >(d1.begin());
2723
}
2724
2725
template<class P_expr1>
2726
inline
2727
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2728
_bz_lgamma<typename P_expr1::T_numtype> > >
2729
lgamma(_bz_ArrayExpr<P_expr1> d1)
2730
{
2731
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2732
_bz_lgamma<typename P_expr1::T_numtype> >(d1);
2733
}
2734
2735
template<int N_index1>
2736
inline
2737
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2738
_bz_lgamma<int> > >
2739
lgamma(IndexPlaceholder<N_index1> d1)
2740
{
2741
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2742
_bz_lgamma<int> >(d1);
2743
}
2744
2745
#endif
2746
2747
/****************************************************************************
2748
* log
2749
****************************************************************************/
2750
2751
template<class T_numtype1, int N_rank1>
2752
inline
2753
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2754
_bz_log<T_numtype1> > >
2755
log(const Array<T_numtype1, N_rank1>& d1)
2756
{
2757
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2758
_bz_log<T_numtype1> >(d1.begin());
2759
}
2760
2761
template<class P_expr1>
2762
inline
2763
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2764
_bz_log<typename P_expr1::T_numtype> > >
2765
log(_bz_ArrayExpr<P_expr1> d1)
2766
{
2767
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2768
_bz_log<typename P_expr1::T_numtype> >(d1);
2769
}
2770
2771
template<int N_index1>
2772
inline
2773
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2774
_bz_log<int> > >
2775
log(IndexPlaceholder<N_index1> d1)
2776
{
2777
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2778
_bz_log<int> >(d1);
2779
}
2780
2781
2782
/****************************************************************************
2783
* logb
2784
****************************************************************************/
2785
2786
#ifdef BZ_HAVE_IEEE_MATH
2787
template<class T_numtype1, int N_rank1>
2788
inline
2789
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2790
_bz_logb<T_numtype1> > >
2791
logb(const Array<T_numtype1, N_rank1>& d1)
2792
{
2793
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2794
_bz_logb<T_numtype1> >(d1.begin());
2795
}
2796
2797
template<class P_expr1>
2798
inline
2799
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2800
_bz_logb<typename P_expr1::T_numtype> > >
2801
logb(_bz_ArrayExpr<P_expr1> d1)
2802
{
2803
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2804
_bz_logb<typename P_expr1::T_numtype> >(d1);
2805
}
2806
2807
template<int N_index1>
2808
inline
2809
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2810
_bz_logb<int> > >
2811
logb(IndexPlaceholder<N_index1> d1)
2812
{
2813
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2814
_bz_logb<int> >(d1);
2815
}
2816
2817
#endif
2818
2819
/****************************************************************************
2820
* log1p
2821
****************************************************************************/
2822
2823
#ifdef BZ_HAVE_IEEE_MATH
2824
template<class T_numtype1, int N_rank1>
2825
inline
2826
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2827
_bz_log1p<T_numtype1> > >
2828
log1p(const Array<T_numtype1, N_rank1>& d1)
2829
{
2830
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2831
_bz_log1p<T_numtype1> >(d1.begin());
2832
}
2833
2834
template<class P_expr1>
2835
inline
2836
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2837
_bz_log1p<typename P_expr1::T_numtype> > >
2838
log1p(_bz_ArrayExpr<P_expr1> d1)
2839
{
2840
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2841
_bz_log1p<typename P_expr1::T_numtype> >(d1);
2842
}
2843
2844
template<int N_index1>
2845
inline
2846
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2847
_bz_log1p<int> > >
2848
log1p(IndexPlaceholder<N_index1> d1)
2849
{
2850
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2851
_bz_log1p<int> >(d1);
2852
}
2853
2854
#endif
2855
2856
/****************************************************************************
2857
* log10
2858
****************************************************************************/
2859
2860
template<class T_numtype1, int N_rank1>
2861
inline
2862
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2863
_bz_log10<T_numtype1> > >
2864
log10(const Array<T_numtype1, N_rank1>& d1)
2865
{
2866
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2867
_bz_log10<T_numtype1> >(d1.begin());
2868
}
2869
2870
template<class P_expr1>
2871
inline
2872
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2873
_bz_log10<typename P_expr1::T_numtype> > >
2874
log10(_bz_ArrayExpr<P_expr1> d1)
2875
{
2876
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2877
_bz_log10<typename P_expr1::T_numtype> >(d1);
2878
}
2879
2880
template<int N_index1>
2881
inline
2882
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2883
_bz_log10<int> > >
2884
log10(IndexPlaceholder<N_index1> d1)
2885
{
2886
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2887
_bz_log10<int> >(d1);
2888
}
2889
2890
2891
/****************************************************************************
2892
* nearest
2893
****************************************************************************/
2894
2895
#ifdef BZ_HAVE_SYSTEM_V_MATH
2896
template<class T_numtype1, int N_rank1>
2897
inline
2898
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2899
_bz_nearest<T_numtype1> > >
2900
nearest(const Array<T_numtype1, N_rank1>& d1)
2901
{
2902
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
2903
_bz_nearest<T_numtype1> >(d1.begin());
2904
}
2905
2906
template<class P_expr1>
2907
inline
2908
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2909
_bz_nearest<typename P_expr1::T_numtype> > >
2910
nearest(_bz_ArrayExpr<P_expr1> d1)
2911
{
2912
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
2913
_bz_nearest<typename P_expr1::T_numtype> >(d1);
2914
}
2915
2916
template<int N_index1>
2917
inline
2918
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2919
_bz_nearest<int> > >
2920
nearest(IndexPlaceholder<N_index1> d1)
2921
{
2922
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
2923
_bz_nearest<int> >(d1);
2924
}
2925
2926
#endif
2927
2928
/****************************************************************************
2929
* nextafter
2930
****************************************************************************/
2931
2932
#ifdef BZ_HAVE_SYSTEM_V_MATH
2933
template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>
2934
inline
2935
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
2936
_bz_nextafter<T_numtype1,T_numtype2> > >
2937
nextafter(const Array<T_numtype1, N_rank1>& d1, const Array<T_numtype2, N_rank2>& d2)
2938
{
2939
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
2940
_bz_nextafter<T_numtype1,T_numtype2> >(d1.begin(), d2.begin());
2941
}
2942
2943
template<class T_numtype1, int N_rank1, class P_expr2>
2944
inline
2945
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
2946
_bz_nextafter<T_numtype1,typename P_expr2::T_numtype> > >
2947
nextafter(const Array<T_numtype1, N_rank1>& d1, _bz_ArrayExpr<P_expr2> d2)
2948
{
2949
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
2950
_bz_nextafter<T_numtype1,typename P_expr2::T_numtype> >(d1.begin(), d2);
2951
}
2952
2953
template<class T_numtype1, int N_rank1, int N_index2>
2954
inline
2955
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
2956
_bz_nextafter<T_numtype1,int> > >
2957
nextafter(const Array<T_numtype1, N_rank1>& d1, IndexPlaceholder<N_index2> d2)
2958
{
2959
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
2960
_bz_nextafter<T_numtype1,int> >(d1.begin(), d2);
2961
}
2962
2963
template<class T_numtype1, int N_rank1>
2964
inline
2965
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
2966
_bz_nextafter<T_numtype1,float> > >
2967
nextafter(const Array<T_numtype1, N_rank1>& d1, float d2)
2968
{
2969
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
2970
_bz_nextafter<T_numtype1,float> >(d1.begin(), _bz_ArrayExprConstant<float>(d2));
2971
}
2972
2973
template<class T_numtype1, int N_rank1>
2974
inline
2975
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
2976
_bz_nextafter<T_numtype1,double> > >
2977
nextafter(const Array<T_numtype1, N_rank1>& d1, double d2)
2978
{
2979
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
2980
_bz_nextafter<T_numtype1,double> >(d1.begin(), _bz_ArrayExprConstant<double>(d2));
2981
}
2982
2983
template<class T_numtype1, int N_rank1>
2984
inline
2985
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
2986
_bz_nextafter<T_numtype1,long double> > >
2987
nextafter(const Array<T_numtype1, N_rank1>& d1, long double d2)
2988
{
2989
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
2990
_bz_nextafter<T_numtype1,long double> >(d1.begin(), _bz_ArrayExprConstant<long double>(d2));
2991
}
2992
2993
#ifdef BZ_HAVE_COMPLEX
2994
template<class T_numtype1, int N_rank1, class T2>
2995
inline
2996
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
2997
_bz_nextafter<T_numtype1,complex<T2> > > >
2998
nextafter(const Array<T_numtype1, N_rank1>& d1, complex<T2> d2)
2999
{
3000
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
3001
_bz_nextafter<T_numtype1,complex<T2> > >(d1.begin(), _bz_ArrayExprConstant<complex<T2> > (d2));
3002
}
3003
3004
#endif // BZ_HAVE_COMPLEX
3005
3006
template<class P_expr1, class T_numtype2, int N_rank2>
3007
inline
3008
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
3009
_bz_nextafter<typename P_expr1::T_numtype,T_numtype2> > >
3010
nextafter(_bz_ArrayExpr<P_expr1> d1, const Array<T_numtype2, N_rank2>& d2)
3011
{
3012
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
3013
_bz_nextafter<typename P_expr1::T_numtype,T_numtype2> >(d1, d2.begin());
3014
}
3015
3016
template<class P_expr1, class P_expr2>
3017
inline
3018
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
3019
_bz_nextafter<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
3020
nextafter(_bz_ArrayExpr<P_expr1> d1, _bz_ArrayExpr<P_expr2> d2)
3021
{
3022
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
3023
_bz_nextafter<typename P_expr1::T_numtype,typename P_expr2::T_numtype> >(d1, d2);
3024
}
3025
3026
template<class P_expr1, int N_index2>
3027
inline
3028
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
3029
_bz_nextafter<typename P_expr1::T_numtype,int> > >
3030
nextafter(_bz_ArrayExpr<P_expr1> d1, IndexPlaceholder<N_index2> d2)
3031
{
3032
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
3033
_bz_nextafter<typename P_expr1::T_numtype,int> >(d1, d2);
3034
}
3035
3036
template<class P_expr1>
3037
inline
3038
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
3039
_bz_nextafter<typename P_expr1::T_numtype,float> > >
3040
nextafter(_bz_ArrayExpr<P_expr1> d1, float d2)
3041
{
3042
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
3043
_bz_nextafter<typename P_expr1::T_numtype,float> >(d1, _bz_ArrayExprConstant<float>(d2));
3044
}
3045
3046
template<class P_expr1>
3047
inline
3048
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
3049
_bz_nextafter<typename P_expr1::T_numtype,double> > >
3050
nextafter(_bz_ArrayExpr<P_expr1> d1, double d2)
3051
{
3052
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
3053
_bz_nextafter<typename P_expr1::T_numtype,double> >(d1, _bz_ArrayExprConstant<double>(d2));
3054
}
3055
3056
template<class P_expr1>
3057
inline
3058
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
3059
_bz_nextafter<typename P_expr1::T_numtype,long double> > >
3060
nextafter(_bz_ArrayExpr<P_expr1> d1, long double d2)
3061
{
3062
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
3063
_bz_nextafter<typename P_expr1::T_numtype,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
3064
}
3065
3066
#ifdef BZ_HAVE_COMPLEX
3067
template<class P_expr1, class T2>
3068
inline
3069
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
3070
_bz_nextafter<typename P_expr1::T_numtype,complex<T2> > > >
3071
nextafter(_bz_ArrayExpr<P_expr1> d1, complex<T2> d2)
3072
{
3073
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
3074
_bz_nextafter<typename P_expr1::T_numtype,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
3075
}
3076
3077
#endif // BZ_HAVE_COMPLEX
3078
3079
template<int N_index1, class T_numtype2, int N_rank2>
3080
inline
3081
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
3082
_bz_nextafter<int,T_numtype2> > >
3083
nextafter(IndexPlaceholder<N_index1> d1, const Array<T_numtype2, N_rank2>& d2)
3084
{
3085
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
3086
_bz_nextafter<int,T_numtype2> >(d1, d2.begin());
3087
}
3088
3089
template<int N_index1, class P_expr2>
3090
inline
3091
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
3092
_bz_nextafter<int,typename P_expr2::T_numtype> > >
3093
nextafter(IndexPlaceholder<N_index1> d1, _bz_ArrayExpr<P_expr2> d2)
3094
{
3095
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
3096
_bz_nextafter<int,typename P_expr2::T_numtype> >(d1, d2);
3097
}
3098
3099
template<int N_index1, int N_index2>
3100
inline
3101
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
3102
_bz_nextafter<int,int> > >
3103
nextafter(IndexPlaceholder<N_index1> d1, IndexPlaceholder<N_index2> d2)
3104
{
3105
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
3106
_bz_nextafter<int,int> >(d1, d2);
3107
}
3108
3109
template<int N_index1>
3110
inline
3111
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
3112
_bz_nextafter<int,float> > >
3113
nextafter(IndexPlaceholder<N_index1> d1, float d2)
3114
{
3115
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
3116
_bz_nextafter<int,float> >(d1, _bz_ArrayExprConstant<float>(d2));
3117
}
3118
3119
template<int N_index1>
3120
inline
3121
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
3122
_bz_nextafter<int,double> > >
3123
nextafter(IndexPlaceholder<N_index1> d1, double d2)
3124
{
3125
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
3126
_bz_nextafter<int,double> >(d1, _bz_ArrayExprConstant<double>(d2));
3127
}
3128
3129
template<int N_index1>
3130
inline
3131
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
3132
_bz_nextafter<int,long double> > >
3133
nextafter(IndexPlaceholder<N_index1> d1, long double d2)
3134
{
3135
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
3136
_bz_nextafter<int,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
3137
}
3138
3139
#ifdef BZ_HAVE_COMPLEX
3140
template<int N_index1, class T2>
3141
inline
3142
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
3143
_bz_nextafter<int,complex<T2> > > >
3144
nextafter(IndexPlaceholder<N_index1> d1, complex<T2> d2)
3145
{
3146
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
3147
_bz_nextafter<int,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
3148
}
3149
3150
#endif // BZ_HAVE_COMPLEX
3151
3152
template<class T_numtype2, int N_rank2>
3153
inline
3154
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
3155
_bz_nextafter<float,T_numtype2> > >
3156
nextafter(float d1, const Array<T_numtype2, N_rank2>& d2)
3157
{
3158
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
3159
_bz_nextafter<float,T_numtype2> >(_bz_ArrayExprConstant<float>(d1), d2.begin());
3160
}
3161
3162
template<class P_expr2>
3163
inline
3164
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
3165
_bz_nextafter<float,typename P_expr2::T_numtype> > >
3166
nextafter(float d1, _bz_ArrayExpr<P_expr2> d2)
3167
{
3168
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
3169
_bz_nextafter<float,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<float>(d1), d2);
3170
}
3171
3172
template<int N_index2>
3173
inline
3174
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
3175
_bz_nextafter<float,int> > >
3176
nextafter(float d1, IndexPlaceholder<N_index2> d2)
3177
{
3178
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
3179
_bz_nextafter<float,int> >(_bz_ArrayExprConstant<float>(d1), d2);
3180
}
3181
3182
template<class T_numtype2, int N_rank2>
3183
inline
3184
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
3185
_bz_nextafter<double,T_numtype2> > >
3186
nextafter(double d1, const Array<T_numtype2, N_rank2>& d2)
3187
{
3188
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
3189
_bz_nextafter<double,T_numtype2> >(_bz_ArrayExprConstant<double>(d1), d2.begin());
3190
}
3191
3192
template<class P_expr2>
3193
inline
3194
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
3195
_bz_nextafter<double,typename P_expr2::T_numtype> > >
3196
nextafter(double d1, _bz_ArrayExpr<P_expr2> d2)
3197
{
3198
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
3199
_bz_nextafter<double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<double>(d1), d2);
3200
}
3201
3202
template<int N_index2>
3203
inline
3204
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
3205
_bz_nextafter<double,int> > >
3206
nextafter(double d1, IndexPlaceholder<N_index2> d2)
3207
{
3208
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
3209
_bz_nextafter<double,int> >(_bz_ArrayExprConstant<double>(d1), d2);
3210
}
3211
3212
template<class T_numtype2, int N_rank2>
3213
inline
3214
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
3215
_bz_nextafter<long double,T_numtype2> > >
3216
nextafter(long double d1, const Array<T_numtype2, N_rank2>& d2)
3217
{
3218
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
3219
_bz_nextafter<long double,T_numtype2> >(_bz_ArrayExprConstant<long double>(d1), d2.begin());
3220
}
3221
3222
template<class P_expr2>
3223
inline
3224
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
3225
_bz_nextafter<long double,typename P_expr2::T_numtype> > >
3226
nextafter(long double d1, _bz_ArrayExpr<P_expr2> d2)
3227
{
3228
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
3229
_bz_nextafter<long double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<long double>(d1), d2);
3230
}
3231
3232
template<int N_index2>
3233
inline
3234
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
3235
_bz_nextafter<long double,int> > >
3236
nextafter(long double d1, IndexPlaceholder<N_index2> d2)
3237
{
3238
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
3239
_bz_nextafter<long double,int> >(_bz_ArrayExprConstant<long double>(d1), d2);
3240
}
3241
3242
#ifdef BZ_HAVE_COMPLEX
3243
template<class T1, class T_numtype2, int N_rank2>
3244
inline
3245
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
3246
_bz_nextafter<complex<T1> ,T_numtype2> > >
3247
nextafter(complex<T1> d1, const Array<T_numtype2, N_rank2>& d2)
3248
{
3249
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
3250
_bz_nextafter<complex<T1> ,T_numtype2> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2.begin());
3251
}
3252
3253
#endif // BZ_HAVE_COMPLEX
3254
3255
#ifdef BZ_HAVE_COMPLEX
3256
template<class T1, class P_expr2>
3257
inline
3258
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
3259
_bz_nextafter<complex<T1> ,typename P_expr2::T_numtype> > >
3260
nextafter(complex<T1> d1, _bz_ArrayExpr<P_expr2> d2)
3261
{
3262
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
3263
_bz_nextafter<complex<T1> ,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
3264
}
3265
3266
#endif // BZ_HAVE_COMPLEX
3267
3268
#ifdef BZ_HAVE_COMPLEX
3269
template<class T1, int N_index2>
3270
inline
3271
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
3272
_bz_nextafter<complex<T1> ,int> > >
3273
nextafter(complex<T1> d1, IndexPlaceholder<N_index2> d2)
3274
{
3275
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
3276
_bz_nextafter<complex<T1> ,int> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
3277
}
3278
3279
#endif // BZ_HAVE_COMPLEX
3280
3281
#endif
3282
3283
/****************************************************************************
3284
* pow
3285
****************************************************************************/
3286
3287
template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>
3288
inline
3289
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
3290
_bz_pow<T_numtype1,T_numtype2> > >
3291
pow(const Array<T_numtype1, N_rank1>& d1, const Array<T_numtype2, N_rank2>& d2)
3292
{
3293
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
3294
_bz_pow<T_numtype1,T_numtype2> >(d1.begin(), d2.begin());
3295
}
3296
3297
template<class T_numtype1, int N_rank1, class P_expr2>
3298
inline
3299
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
3300
_bz_pow<T_numtype1,typename P_expr2::T_numtype> > >
3301
pow(const Array<T_numtype1, N_rank1>& d1, _bz_ArrayExpr<P_expr2> d2)
3302
{
3303
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
3304
_bz_pow<T_numtype1,typename P_expr2::T_numtype> >(d1.begin(), d2);
3305
}
3306
3307
template<class T_numtype1, int N_rank1, int N_index2>
3308
inline
3309
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
3310
_bz_pow<T_numtype1,int> > >
3311
pow(const Array<T_numtype1, N_rank1>& d1, IndexPlaceholder<N_index2> d2)
3312
{
3313
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
3314
_bz_pow<T_numtype1,int> >(d1.begin(), d2);
3315
}
3316
3317
template<class T_numtype1, int N_rank1>
3318
inline
3319
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
3320
_bz_pow<T_numtype1,float> > >
3321
pow(const Array<T_numtype1, N_rank1>& d1, float d2)
3322
{
3323
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
3324
_bz_pow<T_numtype1,float> >(d1.begin(), _bz_ArrayExprConstant<float>(d2));
3325
}
3326
3327
template<class T_numtype1, int N_rank1>
3328
inline
3329
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
3330
_bz_pow<T_numtype1,double> > >
3331
pow(const Array<T_numtype1, N_rank1>& d1, double d2)
3332
{
3333
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
3334
_bz_pow<T_numtype1,double> >(d1.begin(), _bz_ArrayExprConstant<double>(d2));
3335
}
3336
3337
template<class T_numtype1, int N_rank1>
3338
inline
3339
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
3340
_bz_pow<T_numtype1,long double> > >
3341
pow(const Array<T_numtype1, N_rank1>& d1, long double d2)
3342
{
3343
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
3344
_bz_pow<T_numtype1,long double> >(d1.begin(), _bz_ArrayExprConstant<long double>(d2));
3345
}
3346
3347
#ifdef BZ_HAVE_COMPLEX
3348
template<class T_numtype1, int N_rank1, class T2>
3349
inline
3350
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
3351
_bz_pow<T_numtype1,complex<T2> > > >
3352
pow(const Array<T_numtype1, N_rank1>& d1, complex<T2> d2)
3353
{
3354
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
3355
_bz_pow<T_numtype1,complex<T2> > >(d1.begin(), _bz_ArrayExprConstant<complex<T2> > (d2));
3356
}
3357
3358
#endif // BZ_HAVE_COMPLEX
3359
3360
template<class P_expr1, class T_numtype2, int N_rank2>
3361
inline
3362
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
3363
_bz_pow<typename P_expr1::T_numtype,T_numtype2> > >
3364
pow(_bz_ArrayExpr<P_expr1> d1, const Array<T_numtype2, N_rank2>& d2)
3365
{
3366
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
3367
_bz_pow<typename P_expr1::T_numtype,T_numtype2> >(d1, d2.begin());
3368
}
3369
3370
template<class P_expr1, class P_expr2>
3371
inline
3372
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
3373
_bz_pow<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
3374
pow(_bz_ArrayExpr<P_expr1> d1, _bz_ArrayExpr<P_expr2> d2)
3375
{
3376
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
3377
_bz_pow<typename P_expr1::T_numtype,typename P_expr2::T_numtype> >(d1, d2);
3378
}
3379
3380
template<class P_expr1, int N_index2>
3381
inline
3382
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
3383
_bz_pow<typename P_expr1::T_numtype,int> > >
3384
pow(_bz_ArrayExpr<P_expr1> d1, IndexPlaceholder<N_index2> d2)
3385
{
3386
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
3387
_bz_pow<typename P_expr1::T_numtype,int> >(d1, d2);
3388
}
3389
3390
template<class P_expr1>
3391
inline
3392
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
3393
_bz_pow<typename P_expr1::T_numtype,float> > >
3394
pow(_bz_ArrayExpr<P_expr1> d1, float d2)
3395
{
3396
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
3397
_bz_pow<typename P_expr1::T_numtype,float> >(d1, _bz_ArrayExprConstant<float>(d2));
3398
}
3399
3400
template<class P_expr1>
3401
inline
3402
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
3403
_bz_pow<typename P_expr1::T_numtype,double> > >
3404
pow(_bz_ArrayExpr<P_expr1> d1, double d2)
3405
{
3406
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
3407
_bz_pow<typename P_expr1::T_numtype,double> >(d1, _bz_ArrayExprConstant<double>(d2));
3408
}
3409
3410
template<class P_expr1>
3411
inline
3412
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
3413
_bz_pow<typename P_expr1::T_numtype,long double> > >
3414
pow(_bz_ArrayExpr<P_expr1> d1, long double d2)
3415
{
3416
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
3417
_bz_pow<typename P_expr1::T_numtype,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
3418
}
3419
3420
#ifdef BZ_HAVE_COMPLEX
3421
template<class P_expr1, class T2>
3422
inline
3423
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
3424
_bz_pow<typename P_expr1::T_numtype,complex<T2> > > >
3425
pow(_bz_ArrayExpr<P_expr1> d1, complex<T2> d2)
3426
{
3427
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
3428
_bz_pow<typename P_expr1::T_numtype,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
3429
}
3430
3431
#endif // BZ_HAVE_COMPLEX
3432
3433
template<int N_index1, class T_numtype2, int N_rank2>
3434
inline
3435
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
3436
_bz_pow<int,T_numtype2> > >
3437
pow(IndexPlaceholder<N_index1> d1, const Array<T_numtype2, N_rank2>& d2)
3438
{
3439
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
3440
_bz_pow<int,T_numtype2> >(d1, d2.begin());
3441
}
3442
3443
template<int N_index1, class P_expr2>
3444
inline
3445
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
3446
_bz_pow<int,typename P_expr2::T_numtype> > >
3447
pow(IndexPlaceholder<N_index1> d1, _bz_ArrayExpr<P_expr2> d2)
3448
{
3449
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
3450
_bz_pow<int,typename P_expr2::T_numtype> >(d1, d2);
3451
}
3452
3453
template<int N_index1, int N_index2>
3454
inline
3455
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
3456
_bz_pow<int,int> > >
3457
pow(IndexPlaceholder<N_index1> d1, IndexPlaceholder<N_index2> d2)
3458
{
3459
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
3460
_bz_pow<int,int> >(d1, d2);
3461
}
3462
3463
template<int N_index1>
3464
inline
3465
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
3466
_bz_pow<int,float> > >
3467
pow(IndexPlaceholder<N_index1> d1, float d2)
3468
{
3469
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
3470
_bz_pow<int,float> >(d1, _bz_ArrayExprConstant<float>(d2));
3471
}
3472
3473
template<int N_index1>
3474
inline
3475
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
3476
_bz_pow<int,double> > >
3477
pow(IndexPlaceholder<N_index1> d1, double d2)
3478
{
3479
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
3480
_bz_pow<int,double> >(d1, _bz_ArrayExprConstant<double>(d2));
3481
}
3482
3483
template<int N_index1>
3484
inline
3485
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
3486
_bz_pow<int,long double> > >
3487
pow(IndexPlaceholder<N_index1> d1, long double d2)
3488
{
3489
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
3490
_bz_pow<int,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
3491
}
3492
3493
#ifdef BZ_HAVE_COMPLEX
3494
template<int N_index1, class T2>
3495
inline
3496
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
3497
_bz_pow<int,complex<T2> > > >
3498
pow(IndexPlaceholder<N_index1> d1, complex<T2> d2)
3499
{
3500
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
3501
_bz_pow<int,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
3502
}
3503
3504
#endif // BZ_HAVE_COMPLEX
3505
3506
template<class T_numtype2, int N_rank2>
3507
inline
3508
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
3509
_bz_pow<float,T_numtype2> > >
3510
pow(float d1, const Array<T_numtype2, N_rank2>& d2)
3511
{
3512
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
3513
_bz_pow<float,T_numtype2> >(_bz_ArrayExprConstant<float>(d1), d2.begin());
3514
}
3515
3516
template<class P_expr2>
3517
inline
3518
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
3519
_bz_pow<float,typename P_expr2::T_numtype> > >
3520
pow(float d1, _bz_ArrayExpr<P_expr2> d2)
3521
{
3522
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
3523
_bz_pow<float,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<float>(d1), d2);
3524
}
3525
3526
template<int N_index2>
3527
inline
3528
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
3529
_bz_pow<float,int> > >
3530
pow(float d1, IndexPlaceholder<N_index2> d2)
3531
{
3532
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
3533
_bz_pow<float,int> >(_bz_ArrayExprConstant<float>(d1), d2);
3534
}
3535
3536
template<class T_numtype2, int N_rank2>
3537
inline
3538
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
3539
_bz_pow<double,T_numtype2> > >
3540
pow(double d1, const Array<T_numtype2, N_rank2>& d2)
3541
{
3542
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
3543
_bz_pow<double,T_numtype2> >(_bz_ArrayExprConstant<double>(d1), d2.begin());
3544
}
3545
3546
template<class P_expr2>
3547
inline
3548
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
3549
_bz_pow<double,typename P_expr2::T_numtype> > >
3550
pow(double d1, _bz_ArrayExpr<P_expr2> d2)
3551
{
3552
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
3553
_bz_pow<double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<double>(d1), d2);
3554
}
3555
3556
template<int N_index2>
3557
inline
3558
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
3559
_bz_pow<double,int> > >
3560
pow(double d1, IndexPlaceholder<N_index2> d2)
3561
{
3562
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
3563
_bz_pow<double,int> >(_bz_ArrayExprConstant<double>(d1), d2);
3564
}
3565
3566
template<class T_numtype2, int N_rank2>
3567
inline
3568
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
3569
_bz_pow<long double,T_numtype2> > >
3570
pow(long double d1, const Array<T_numtype2, N_rank2>& d2)
3571
{
3572
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
3573
_bz_pow<long double,T_numtype2> >(_bz_ArrayExprConstant<long double>(d1), d2.begin());
3574
}
3575
3576
template<class P_expr2>
3577
inline
3578
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
3579
_bz_pow<long double,typename P_expr2::T_numtype> > >
3580
pow(long double d1, _bz_ArrayExpr<P_expr2> d2)
3581
{
3582
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
3583
_bz_pow<long double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<long double>(d1), d2);
3584
}
3585
3586
template<int N_index2>
3587
inline
3588
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
3589
_bz_pow<long double,int> > >
3590
pow(long double d1, IndexPlaceholder<N_index2> d2)
3591
{
3592
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
3593
_bz_pow<long double,int> >(_bz_ArrayExprConstant<long double>(d1), d2);
3594
}
3595
3596
#ifdef BZ_HAVE_COMPLEX
3597
template<class T1, class T_numtype2, int N_rank2>
3598
inline
3599
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
3600
_bz_pow<complex<T1> ,T_numtype2> > >
3601
pow(complex<T1> d1, const Array<T_numtype2, N_rank2>& d2)
3602
{
3603
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
3604
_bz_pow<complex<T1> ,T_numtype2> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2.begin());
3605
}
3606
3607
#endif // BZ_HAVE_COMPLEX
3608
3609
#ifdef BZ_HAVE_COMPLEX
3610
template<class T1, class P_expr2>
3611
inline
3612
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
3613
_bz_pow<complex<T1> ,typename P_expr2::T_numtype> > >
3614
pow(complex<T1> d1, _bz_ArrayExpr<P_expr2> d2)
3615
{
3616
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
3617
_bz_pow<complex<T1> ,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
3618
}
3619
3620
#endif // BZ_HAVE_COMPLEX
3621
3622
#ifdef BZ_HAVE_COMPLEX
3623
template<class T1, int N_index2>
3624
inline
3625
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
3626
_bz_pow<complex<T1> ,int> > >
3627
pow(complex<T1> d1, IndexPlaceholder<N_index2> d2)
3628
{
3629
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
3630
_bz_pow<complex<T1> ,int> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
3631
}
3632
3633
#endif // BZ_HAVE_COMPLEX
3634
3635
3636
/****************************************************************************
3637
* pow2
3638
****************************************************************************/
3639
3640
template<class T_numtype1, int N_rank1>
3641
inline
3642
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3643
_bz_pow2<T_numtype1> > >
3644
pow2(const Array<T_numtype1, N_rank1>& d1)
3645
{
3646
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3647
_bz_pow2<T_numtype1> >(d1.begin());
3648
}
3649
3650
template<class P_expr1>
3651
inline
3652
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3653
_bz_pow2<typename P_expr1::T_numtype> > >
3654
pow2(_bz_ArrayExpr<P_expr1> d1)
3655
{
3656
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3657
_bz_pow2<typename P_expr1::T_numtype> >(d1);
3658
}
3659
3660
template<int N_index1>
3661
inline
3662
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3663
_bz_pow2<int> > >
3664
pow2(IndexPlaceholder<N_index1> d1)
3665
{
3666
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3667
_bz_pow2<int> >(d1);
3668
}
3669
3670
3671
/****************************************************************************
3672
* pow3
3673
****************************************************************************/
3674
3675
template<class T_numtype1, int N_rank1>
3676
inline
3677
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3678
_bz_pow3<T_numtype1> > >
3679
pow3(const Array<T_numtype1, N_rank1>& d1)
3680
{
3681
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3682
_bz_pow3<T_numtype1> >(d1.begin());
3683
}
3684
3685
template<class P_expr1>
3686
inline
3687
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3688
_bz_pow3<typename P_expr1::T_numtype> > >
3689
pow3(_bz_ArrayExpr<P_expr1> d1)
3690
{
3691
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3692
_bz_pow3<typename P_expr1::T_numtype> >(d1);
3693
}
3694
3695
template<int N_index1>
3696
inline
3697
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3698
_bz_pow3<int> > >
3699
pow3(IndexPlaceholder<N_index1> d1)
3700
{
3701
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3702
_bz_pow3<int> >(d1);
3703
}
3704
3705
3706
/****************************************************************************
3707
* pow4
3708
****************************************************************************/
3709
3710
template<class T_numtype1, int N_rank1>
3711
inline
3712
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3713
_bz_pow4<T_numtype1> > >
3714
pow4(const Array<T_numtype1, N_rank1>& d1)
3715
{
3716
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3717
_bz_pow4<T_numtype1> >(d1.begin());
3718
}
3719
3720
template<class P_expr1>
3721
inline
3722
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3723
_bz_pow4<typename P_expr1::T_numtype> > >
3724
pow4(_bz_ArrayExpr<P_expr1> d1)
3725
{
3726
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3727
_bz_pow4<typename P_expr1::T_numtype> >(d1);
3728
}
3729
3730
template<int N_index1>
3731
inline
3732
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3733
_bz_pow4<int> > >
3734
pow4(IndexPlaceholder<N_index1> d1)
3735
{
3736
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3737
_bz_pow4<int> >(d1);
3738
}
3739
3740
3741
/****************************************************************************
3742
* pow5
3743
****************************************************************************/
3744
3745
template<class T_numtype1, int N_rank1>
3746
inline
3747
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3748
_bz_pow5<T_numtype1> > >
3749
pow5(const Array<T_numtype1, N_rank1>& d1)
3750
{
3751
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3752
_bz_pow5<T_numtype1> >(d1.begin());
3753
}
3754
3755
template<class P_expr1>
3756
inline
3757
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3758
_bz_pow5<typename P_expr1::T_numtype> > >
3759
pow5(_bz_ArrayExpr<P_expr1> d1)
3760
{
3761
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3762
_bz_pow5<typename P_expr1::T_numtype> >(d1);
3763
}
3764
3765
template<int N_index1>
3766
inline
3767
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3768
_bz_pow5<int> > >
3769
pow5(IndexPlaceholder<N_index1> d1)
3770
{
3771
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3772
_bz_pow5<int> >(d1);
3773
}
3774
3775
3776
/****************************************************************************
3777
* pow6
3778
****************************************************************************/
3779
3780
template<class T_numtype1, int N_rank1>
3781
inline
3782
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3783
_bz_pow6<T_numtype1> > >
3784
pow6(const Array<T_numtype1, N_rank1>& d1)
3785
{
3786
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3787
_bz_pow6<T_numtype1> >(d1.begin());
3788
}
3789
3790
template<class P_expr1>
3791
inline
3792
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3793
_bz_pow6<typename P_expr1::T_numtype> > >
3794
pow6(_bz_ArrayExpr<P_expr1> d1)
3795
{
3796
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3797
_bz_pow6<typename P_expr1::T_numtype> >(d1);
3798
}
3799
3800
template<int N_index1>
3801
inline
3802
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3803
_bz_pow6<int> > >
3804
pow6(IndexPlaceholder<N_index1> d1)
3805
{
3806
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3807
_bz_pow6<int> >(d1);
3808
}
3809
3810
3811
/****************************************************************************
3812
* pow7
3813
****************************************************************************/
3814
3815
template<class T_numtype1, int N_rank1>
3816
inline
3817
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3818
_bz_pow7<T_numtype1> > >
3819
pow7(const Array<T_numtype1, N_rank1>& d1)
3820
{
3821
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3822
_bz_pow7<T_numtype1> >(d1.begin());
3823
}
3824
3825
template<class P_expr1>
3826
inline
3827
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3828
_bz_pow7<typename P_expr1::T_numtype> > >
3829
pow7(_bz_ArrayExpr<P_expr1> d1)
3830
{
3831
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3832
_bz_pow7<typename P_expr1::T_numtype> >(d1);
3833
}
3834
3835
template<int N_index1>
3836
inline
3837
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3838
_bz_pow7<int> > >
3839
pow7(IndexPlaceholder<N_index1> d1)
3840
{
3841
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3842
_bz_pow7<int> >(d1);
3843
}
3844
3845
3846
/****************************************************************************
3847
* pow8
3848
****************************************************************************/
3849
3850
template<class T_numtype1, int N_rank1>
3851
inline
3852
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3853
_bz_pow8<T_numtype1> > >
3854
pow8(const Array<T_numtype1, N_rank1>& d1)
3855
{
3856
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
3857
_bz_pow8<T_numtype1> >(d1.begin());
3858
}
3859
3860
template<class P_expr1>
3861
inline
3862
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3863
_bz_pow8<typename P_expr1::T_numtype> > >
3864
pow8(_bz_ArrayExpr<P_expr1> d1)
3865
{
3866
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
3867
_bz_pow8<typename P_expr1::T_numtype> >(d1);
3868
}
3869
3870
template<int N_index1>
3871
inline
3872
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3873
_bz_pow8<int> > >
3874
pow8(IndexPlaceholder<N_index1> d1)
3875
{
3876
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
3877
_bz_pow8<int> >(d1);
3878
}
3879
3880
3881
/****************************************************************************
3882
* remainder
3883
****************************************************************************/
3884
3885
#ifdef BZ_HAVE_SYSTEM_V_MATH
3886
template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>
3887
inline
3888
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
3889
_bz_remainder<T_numtype1,T_numtype2> > >
3890
remainder(const Array<T_numtype1, N_rank1>& d1, const Array<T_numtype2, N_rank2>& d2)
3891
{
3892
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
3893
_bz_remainder<T_numtype1,T_numtype2> >(d1.begin(), d2.begin());
3894
}
3895
3896
template<class T_numtype1, int N_rank1, class P_expr2>
3897
inline
3898
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
3899
_bz_remainder<T_numtype1,typename P_expr2::T_numtype> > >
3900
remainder(const Array<T_numtype1, N_rank1>& d1, _bz_ArrayExpr<P_expr2> d2)
3901
{
3902
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
3903
_bz_remainder<T_numtype1,typename P_expr2::T_numtype> >(d1.begin(), d2);
3904
}
3905
3906
template<class T_numtype1, int N_rank1, int N_index2>
3907
inline
3908
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
3909
_bz_remainder<T_numtype1,int> > >
3910
remainder(const Array<T_numtype1, N_rank1>& d1, IndexPlaceholder<N_index2> d2)
3911
{
3912
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
3913
_bz_remainder<T_numtype1,int> >(d1.begin(), d2);
3914
}
3915
3916
template<class T_numtype1, int N_rank1>
3917
inline
3918
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
3919
_bz_remainder<T_numtype1,float> > >
3920
remainder(const Array<T_numtype1, N_rank1>& d1, float d2)
3921
{
3922
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
3923
_bz_remainder<T_numtype1,float> >(d1.begin(), _bz_ArrayExprConstant<float>(d2));
3924
}
3925
3926
template<class T_numtype1, int N_rank1>
3927
inline
3928
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
3929
_bz_remainder<T_numtype1,double> > >
3930
remainder(const Array<T_numtype1, N_rank1>& d1, double d2)
3931
{
3932
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
3933
_bz_remainder<T_numtype1,double> >(d1.begin(), _bz_ArrayExprConstant<double>(d2));
3934
}
3935
3936
template<class T_numtype1, int N_rank1>
3937
inline
3938
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
3939
_bz_remainder<T_numtype1,long double> > >
3940
remainder(const Array<T_numtype1, N_rank1>& d1, long double d2)
3941
{
3942
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
3943
_bz_remainder<T_numtype1,long double> >(d1.begin(), _bz_ArrayExprConstant<long double>(d2));
3944
}
3945
3946
#ifdef BZ_HAVE_COMPLEX
3947
template<class T_numtype1, int N_rank1, class T2>
3948
inline
3949
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
3950
_bz_remainder<T_numtype1,complex<T2> > > >
3951
remainder(const Array<T_numtype1, N_rank1>& d1, complex<T2> d2)
3952
{
3953
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
3954
_bz_remainder<T_numtype1,complex<T2> > >(d1.begin(), _bz_ArrayExprConstant<complex<T2> > (d2));
3955
}
3956
3957
#endif // BZ_HAVE_COMPLEX
3958
3959
template<class P_expr1, class T_numtype2, int N_rank2>
3960
inline
3961
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
3962
_bz_remainder<typename P_expr1::T_numtype,T_numtype2> > >
3963
remainder(_bz_ArrayExpr<P_expr1> d1, const Array<T_numtype2, N_rank2>& d2)
3964
{
3965
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
3966
_bz_remainder<typename P_expr1::T_numtype,T_numtype2> >(d1, d2.begin());
3967
}
3968
3969
template<class P_expr1, class P_expr2>
3970
inline
3971
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
3972
_bz_remainder<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
3973
remainder(_bz_ArrayExpr<P_expr1> d1, _bz_ArrayExpr<P_expr2> d2)
3974
{
3975
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
3976
_bz_remainder<typename P_expr1::T_numtype,typename P_expr2::T_numtype> >(d1, d2);
3977
}
3978
3979
template<class P_expr1, int N_index2>
3980
inline
3981
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
3982
_bz_remainder<typename P_expr1::T_numtype,int> > >
3983
remainder(_bz_ArrayExpr<P_expr1> d1, IndexPlaceholder<N_index2> d2)
3984
{
3985
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
3986
_bz_remainder<typename P_expr1::T_numtype,int> >(d1, d2);
3987
}
3988
3989
template<class P_expr1>
3990
inline
3991
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
3992
_bz_remainder<typename P_expr1::T_numtype,float> > >
3993
remainder(_bz_ArrayExpr<P_expr1> d1, float d2)
3994
{
3995
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
3996
_bz_remainder<typename P_expr1::T_numtype,float> >(d1, _bz_ArrayExprConstant<float>(d2));
3997
}
3998
3999
template<class P_expr1>
4000
inline
4001
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
4002
_bz_remainder<typename P_expr1::T_numtype,double> > >
4003
remainder(_bz_ArrayExpr<P_expr1> d1, double d2)
4004
{
4005
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
4006
_bz_remainder<typename P_expr1::T_numtype,double> >(d1, _bz_ArrayExprConstant<double>(d2));
4007
}
4008
4009
template<class P_expr1>
4010
inline
4011
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
4012
_bz_remainder<typename P_expr1::T_numtype,long double> > >
4013
remainder(_bz_ArrayExpr<P_expr1> d1, long double d2)
4014
{
4015
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
4016
_bz_remainder<typename P_expr1::T_numtype,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
4017
}
4018
4019
#ifdef BZ_HAVE_COMPLEX
4020
template<class P_expr1, class T2>
4021
inline
4022
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
4023
_bz_remainder<typename P_expr1::T_numtype,complex<T2> > > >
4024
remainder(_bz_ArrayExpr<P_expr1> d1, complex<T2> d2)
4025
{
4026
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
4027
_bz_remainder<typename P_expr1::T_numtype,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
4028
}
4029
4030
#endif // BZ_HAVE_COMPLEX
4031
4032
template<int N_index1, class T_numtype2, int N_rank2>
4033
inline
4034
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
4035
_bz_remainder<int,T_numtype2> > >
4036
remainder(IndexPlaceholder<N_index1> d1, const Array<T_numtype2, N_rank2>& d2)
4037
{
4038
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
4039
_bz_remainder<int,T_numtype2> >(d1, d2.begin());
4040
}
4041
4042
template<int N_index1, class P_expr2>
4043
inline
4044
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
4045
_bz_remainder<int,typename P_expr2::T_numtype> > >
4046
remainder(IndexPlaceholder<N_index1> d1, _bz_ArrayExpr<P_expr2> d2)
4047
{
4048
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
4049
_bz_remainder<int,typename P_expr2::T_numtype> >(d1, d2);
4050
}
4051
4052
template<int N_index1, int N_index2>
4053
inline
4054
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
4055
_bz_remainder<int,int> > >
4056
remainder(IndexPlaceholder<N_index1> d1, IndexPlaceholder<N_index2> d2)
4057
{
4058
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
4059
_bz_remainder<int,int> >(d1, d2);
4060
}
4061
4062
template<int N_index1>
4063
inline
4064
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
4065
_bz_remainder<int,float> > >
4066
remainder(IndexPlaceholder<N_index1> d1, float d2)
4067
{
4068
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
4069
_bz_remainder<int,float> >(d1, _bz_ArrayExprConstant<float>(d2));
4070
}
4071
4072
template<int N_index1>
4073
inline
4074
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
4075
_bz_remainder<int,double> > >
4076
remainder(IndexPlaceholder<N_index1> d1, double d2)
4077
{
4078
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
4079
_bz_remainder<int,double> >(d1, _bz_ArrayExprConstant<double>(d2));
4080
}
4081
4082
template<int N_index1>
4083
inline
4084
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
4085
_bz_remainder<int,long double> > >
4086
remainder(IndexPlaceholder<N_index1> d1, long double d2)
4087
{
4088
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
4089
_bz_remainder<int,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
4090
}
4091
4092
#ifdef BZ_HAVE_COMPLEX
4093
template<int N_index1, class T2>
4094
inline
4095
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
4096
_bz_remainder<int,complex<T2> > > >
4097
remainder(IndexPlaceholder<N_index1> d1, complex<T2> d2)
4098
{
4099
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
4100
_bz_remainder<int,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
4101
}
4102
4103
#endif // BZ_HAVE_COMPLEX
4104
4105
template<class T_numtype2, int N_rank2>
4106
inline
4107
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
4108
_bz_remainder<float,T_numtype2> > >
4109
remainder(float d1, const Array<T_numtype2, N_rank2>& d2)
4110
{
4111
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
4112
_bz_remainder<float,T_numtype2> >(_bz_ArrayExprConstant<float>(d1), d2.begin());
4113
}
4114
4115
template<class P_expr2>
4116
inline
4117
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
4118
_bz_remainder<float,typename P_expr2::T_numtype> > >
4119
remainder(float d1, _bz_ArrayExpr<P_expr2> d2)
4120
{
4121
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
4122
_bz_remainder<float,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<float>(d1), d2);
4123
}
4124
4125
template<int N_index2>
4126
inline
4127
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
4128
_bz_remainder<float,int> > >
4129
remainder(float d1, IndexPlaceholder<N_index2> d2)
4130
{
4131
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
4132
_bz_remainder<float,int> >(_bz_ArrayExprConstant<float>(d1), d2);
4133
}
4134
4135
template<class T_numtype2, int N_rank2>
4136
inline
4137
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
4138
_bz_remainder<double,T_numtype2> > >
4139
remainder(double d1, const Array<T_numtype2, N_rank2>& d2)
4140
{
4141
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
4142
_bz_remainder<double,T_numtype2> >(_bz_ArrayExprConstant<double>(d1), d2.begin());
4143
}
4144
4145
template<class P_expr2>
4146
inline
4147
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
4148
_bz_remainder<double,typename P_expr2::T_numtype> > >
4149
remainder(double d1, _bz_ArrayExpr<P_expr2> d2)
4150
{
4151
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
4152
_bz_remainder<double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<double>(d1), d2);
4153
}
4154
4155
template<int N_index2>
4156
inline
4157
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
4158
_bz_remainder<double,int> > >
4159
remainder(double d1, IndexPlaceholder<N_index2> d2)
4160
{
4161
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
4162
_bz_remainder<double,int> >(_bz_ArrayExprConstant<double>(d1), d2);
4163
}
4164
4165
template<class T_numtype2, int N_rank2>
4166
inline
4167
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
4168
_bz_remainder<long double,T_numtype2> > >
4169
remainder(long double d1, const Array<T_numtype2, N_rank2>& d2)
4170
{
4171
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
4172
_bz_remainder<long double,T_numtype2> >(_bz_ArrayExprConstant<long double>(d1), d2.begin());
4173
}
4174
4175
template<class P_expr2>
4176
inline
4177
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
4178
_bz_remainder<long double,typename P_expr2::T_numtype> > >
4179
remainder(long double d1, _bz_ArrayExpr<P_expr2> d2)
4180
{
4181
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
4182
_bz_remainder<long double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<long double>(d1), d2);
4183
}
4184
4185
template<int N_index2>
4186
inline
4187
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
4188
_bz_remainder<long double,int> > >
4189
remainder(long double d1, IndexPlaceholder<N_index2> d2)
4190
{
4191
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
4192
_bz_remainder<long double,int> >(_bz_ArrayExprConstant<long double>(d1), d2);
4193
}
4194
4195
#ifdef BZ_HAVE_COMPLEX
4196
template<class T1, class T_numtype2, int N_rank2>
4197
inline
4198
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
4199
_bz_remainder<complex<T1> ,T_numtype2> > >
4200
remainder(complex<T1> d1, const Array<T_numtype2, N_rank2>& d2)
4201
{
4202
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
4203
_bz_remainder<complex<T1> ,T_numtype2> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2.begin());
4204
}
4205
4206
#endif // BZ_HAVE_COMPLEX
4207
4208
#ifdef BZ_HAVE_COMPLEX
4209
template<class T1, class P_expr2>
4210
inline
4211
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
4212
_bz_remainder<complex<T1> ,typename P_expr2::T_numtype> > >
4213
remainder(complex<T1> d1, _bz_ArrayExpr<P_expr2> d2)
4214
{
4215
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
4216
_bz_remainder<complex<T1> ,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
4217
}
4218
4219
#endif // BZ_HAVE_COMPLEX
4220
4221
#ifdef BZ_HAVE_COMPLEX
4222
template<class T1, int N_index2>
4223
inline
4224
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
4225
_bz_remainder<complex<T1> ,int> > >
4226
remainder(complex<T1> d1, IndexPlaceholder<N_index2> d2)
4227
{
4228
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
4229
_bz_remainder<complex<T1> ,int> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
4230
}
4231
4232
#endif // BZ_HAVE_COMPLEX
4233
4234
#endif
4235
4236
/****************************************************************************
4237
* rint
4238
****************************************************************************/
4239
4240
#ifdef BZ_HAVE_IEEE_MATH
4241
template<class T_numtype1, int N_rank1>
4242
inline
4243
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4244
_bz_rint<T_numtype1> > >
4245
rint(const Array<T_numtype1, N_rank1>& d1)
4246
{
4247
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4248
_bz_rint<T_numtype1> >(d1.begin());
4249
}
4250
4251
template<class P_expr1>
4252
inline
4253
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4254
_bz_rint<typename P_expr1::T_numtype> > >
4255
rint(_bz_ArrayExpr<P_expr1> d1)
4256
{
4257
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4258
_bz_rint<typename P_expr1::T_numtype> >(d1);
4259
}
4260
4261
template<int N_index1>
4262
inline
4263
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4264
_bz_rint<int> > >
4265
rint(IndexPlaceholder<N_index1> d1)
4266
{
4267
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4268
_bz_rint<int> >(d1);
4269
}
4270
4271
#endif
4272
4273
/****************************************************************************
4274
* rsqrt
4275
****************************************************************************/
4276
4277
#ifdef BZ_HAVE_SYSTEM_V_MATH
4278
template<class T_numtype1, int N_rank1>
4279
inline
4280
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4281
_bz_rsqrt<T_numtype1> > >
4282
rsqrt(const Array<T_numtype1, N_rank1>& d1)
4283
{
4284
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4285
_bz_rsqrt<T_numtype1> >(d1.begin());
4286
}
4287
4288
template<class P_expr1>
4289
inline
4290
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4291
_bz_rsqrt<typename P_expr1::T_numtype> > >
4292
rsqrt(_bz_ArrayExpr<P_expr1> d1)
4293
{
4294
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4295
_bz_rsqrt<typename P_expr1::T_numtype> >(d1);
4296
}
4297
4298
template<int N_index1>
4299
inline
4300
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4301
_bz_rsqrt<int> > >
4302
rsqrt(IndexPlaceholder<N_index1> d1)
4303
{
4304
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4305
_bz_rsqrt<int> >(d1);
4306
}
4307
4308
#endif
4309
4310
/****************************************************************************
4311
* scalb
4312
****************************************************************************/
4313
4314
#ifdef BZ_HAVE_SYSTEM_V_MATH
4315
template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>
4316
inline
4317
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
4318
_bz_scalb<T_numtype1,T_numtype2> > >
4319
scalb(const Array<T_numtype1, N_rank1>& d1, const Array<T_numtype2, N_rank2>& d2)
4320
{
4321
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
4322
_bz_scalb<T_numtype1,T_numtype2> >(d1.begin(), d2.begin());
4323
}
4324
4325
template<class T_numtype1, int N_rank1, class P_expr2>
4326
inline
4327
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
4328
_bz_scalb<T_numtype1,typename P_expr2::T_numtype> > >
4329
scalb(const Array<T_numtype1, N_rank1>& d1, _bz_ArrayExpr<P_expr2> d2)
4330
{
4331
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
4332
_bz_scalb<T_numtype1,typename P_expr2::T_numtype> >(d1.begin(), d2);
4333
}
4334
4335
template<class T_numtype1, int N_rank1, int N_index2>
4336
inline
4337
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
4338
_bz_scalb<T_numtype1,int> > >
4339
scalb(const Array<T_numtype1, N_rank1>& d1, IndexPlaceholder<N_index2> d2)
4340
{
4341
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
4342
_bz_scalb<T_numtype1,int> >(d1.begin(), d2);
4343
}
4344
4345
template<class T_numtype1, int N_rank1>
4346
inline
4347
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
4348
_bz_scalb<T_numtype1,float> > >
4349
scalb(const Array<T_numtype1, N_rank1>& d1, float d2)
4350
{
4351
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
4352
_bz_scalb<T_numtype1,float> >(d1.begin(), _bz_ArrayExprConstant<float>(d2));
4353
}
4354
4355
template<class T_numtype1, int N_rank1>
4356
inline
4357
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
4358
_bz_scalb<T_numtype1,double> > >
4359
scalb(const Array<T_numtype1, N_rank1>& d1, double d2)
4360
{
4361
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
4362
_bz_scalb<T_numtype1,double> >(d1.begin(), _bz_ArrayExprConstant<double>(d2));
4363
}
4364
4365
template<class T_numtype1, int N_rank1>
4366
inline
4367
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
4368
_bz_scalb<T_numtype1,long double> > >
4369
scalb(const Array<T_numtype1, N_rank1>& d1, long double d2)
4370
{
4371
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
4372
_bz_scalb<T_numtype1,long double> >(d1.begin(), _bz_ArrayExprConstant<long double>(d2));
4373
}
4374
4375
#ifdef BZ_HAVE_COMPLEX
4376
template<class T_numtype1, int N_rank1, class T2>
4377
inline
4378
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
4379
_bz_scalb<T_numtype1,complex<T2> > > >
4380
scalb(const Array<T_numtype1, N_rank1>& d1, complex<T2> d2)
4381
{
4382
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
4383
_bz_scalb<T_numtype1,complex<T2> > >(d1.begin(), _bz_ArrayExprConstant<complex<T2> > (d2));
4384
}
4385
4386
#endif // BZ_HAVE_COMPLEX
4387
4388
template<class P_expr1, class T_numtype2, int N_rank2>
4389
inline
4390
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
4391
_bz_scalb<typename P_expr1::T_numtype,T_numtype2> > >
4392
scalb(_bz_ArrayExpr<P_expr1> d1, const Array<T_numtype2, N_rank2>& d2)
4393
{
4394
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
4395
_bz_scalb<typename P_expr1::T_numtype,T_numtype2> >(d1, d2.begin());
4396
}
4397
4398
template<class P_expr1, class P_expr2>
4399
inline
4400
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
4401
_bz_scalb<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
4402
scalb(_bz_ArrayExpr<P_expr1> d1, _bz_ArrayExpr<P_expr2> d2)
4403
{
4404
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
4405
_bz_scalb<typename P_expr1::T_numtype,typename P_expr2::T_numtype> >(d1, d2);
4406
}
4407
4408
template<class P_expr1, int N_index2>
4409
inline
4410
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
4411
_bz_scalb<typename P_expr1::T_numtype,int> > >
4412
scalb(_bz_ArrayExpr<P_expr1> d1, IndexPlaceholder<N_index2> d2)
4413
{
4414
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
4415
_bz_scalb<typename P_expr1::T_numtype,int> >(d1, d2);
4416
}
4417
4418
template<class P_expr1>
4419
inline
4420
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
4421
_bz_scalb<typename P_expr1::T_numtype,float> > >
4422
scalb(_bz_ArrayExpr<P_expr1> d1, float d2)
4423
{
4424
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
4425
_bz_scalb<typename P_expr1::T_numtype,float> >(d1, _bz_ArrayExprConstant<float>(d2));
4426
}
4427
4428
template<class P_expr1>
4429
inline
4430
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
4431
_bz_scalb<typename P_expr1::T_numtype,double> > >
4432
scalb(_bz_ArrayExpr<P_expr1> d1, double d2)
4433
{
4434
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
4435
_bz_scalb<typename P_expr1::T_numtype,double> >(d1, _bz_ArrayExprConstant<double>(d2));
4436
}
4437
4438
template<class P_expr1>
4439
inline
4440
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
4441
_bz_scalb<typename P_expr1::T_numtype,long double> > >
4442
scalb(_bz_ArrayExpr<P_expr1> d1, long double d2)
4443
{
4444
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
4445
_bz_scalb<typename P_expr1::T_numtype,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
4446
}
4447
4448
#ifdef BZ_HAVE_COMPLEX
4449
template<class P_expr1, class T2>
4450
inline
4451
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
4452
_bz_scalb<typename P_expr1::T_numtype,complex<T2> > > >
4453
scalb(_bz_ArrayExpr<P_expr1> d1, complex<T2> d2)
4454
{
4455
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
4456
_bz_scalb<typename P_expr1::T_numtype,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
4457
}
4458
4459
#endif // BZ_HAVE_COMPLEX
4460
4461
template<int N_index1, class T_numtype2, int N_rank2>
4462
inline
4463
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
4464
_bz_scalb<int,T_numtype2> > >
4465
scalb(IndexPlaceholder<N_index1> d1, const Array<T_numtype2, N_rank2>& d2)
4466
{
4467
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
4468
_bz_scalb<int,T_numtype2> >(d1, d2.begin());
4469
}
4470
4471
template<int N_index1, class P_expr2>
4472
inline
4473
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
4474
_bz_scalb<int,typename P_expr2::T_numtype> > >
4475
scalb(IndexPlaceholder<N_index1> d1, _bz_ArrayExpr<P_expr2> d2)
4476
{
4477
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
4478
_bz_scalb<int,typename P_expr2::T_numtype> >(d1, d2);
4479
}
4480
4481
template<int N_index1, int N_index2>
4482
inline
4483
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
4484
_bz_scalb<int,int> > >
4485
scalb(IndexPlaceholder<N_index1> d1, IndexPlaceholder<N_index2> d2)
4486
{
4487
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
4488
_bz_scalb<int,int> >(d1, d2);
4489
}
4490
4491
template<int N_index1>
4492
inline
4493
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
4494
_bz_scalb<int,float> > >
4495
scalb(IndexPlaceholder<N_index1> d1, float d2)
4496
{
4497
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
4498
_bz_scalb<int,float> >(d1, _bz_ArrayExprConstant<float>(d2));
4499
}
4500
4501
template<int N_index1>
4502
inline
4503
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
4504
_bz_scalb<int,double> > >
4505
scalb(IndexPlaceholder<N_index1> d1, double d2)
4506
{
4507
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
4508
_bz_scalb<int,double> >(d1, _bz_ArrayExprConstant<double>(d2));
4509
}
4510
4511
template<int N_index1>
4512
inline
4513
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
4514
_bz_scalb<int,long double> > >
4515
scalb(IndexPlaceholder<N_index1> d1, long double d2)
4516
{
4517
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
4518
_bz_scalb<int,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
4519
}
4520
4521
#ifdef BZ_HAVE_COMPLEX
4522
template<int N_index1, class T2>
4523
inline
4524
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
4525
_bz_scalb<int,complex<T2> > > >
4526
scalb(IndexPlaceholder<N_index1> d1, complex<T2> d2)
4527
{
4528
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
4529
_bz_scalb<int,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
4530
}
4531
4532
#endif // BZ_HAVE_COMPLEX
4533
4534
template<class T_numtype2, int N_rank2>
4535
inline
4536
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
4537
_bz_scalb<float,T_numtype2> > >
4538
scalb(float d1, const Array<T_numtype2, N_rank2>& d2)
4539
{
4540
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
4541
_bz_scalb<float,T_numtype2> >(_bz_ArrayExprConstant<float>(d1), d2.begin());
4542
}
4543
4544
template<class P_expr2>
4545
inline
4546
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
4547
_bz_scalb<float,typename P_expr2::T_numtype> > >
4548
scalb(float d1, _bz_ArrayExpr<P_expr2> d2)
4549
{
4550
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
4551
_bz_scalb<float,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<float>(d1), d2);
4552
}
4553
4554
template<int N_index2>
4555
inline
4556
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
4557
_bz_scalb<float,int> > >
4558
scalb(float d1, IndexPlaceholder<N_index2> d2)
4559
{
4560
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
4561
_bz_scalb<float,int> >(_bz_ArrayExprConstant<float>(d1), d2);
4562
}
4563
4564
template<class T_numtype2, int N_rank2>
4565
inline
4566
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
4567
_bz_scalb<double,T_numtype2> > >
4568
scalb(double d1, const Array<T_numtype2, N_rank2>& d2)
4569
{
4570
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
4571
_bz_scalb<double,T_numtype2> >(_bz_ArrayExprConstant<double>(d1), d2.begin());
4572
}
4573
4574
template<class P_expr2>
4575
inline
4576
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
4577
_bz_scalb<double,typename P_expr2::T_numtype> > >
4578
scalb(double d1, _bz_ArrayExpr<P_expr2> d2)
4579
{
4580
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
4581
_bz_scalb<double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<double>(d1), d2);
4582
}
4583
4584
template<int N_index2>
4585
inline
4586
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
4587
_bz_scalb<double,int> > >
4588
scalb(double d1, IndexPlaceholder<N_index2> d2)
4589
{
4590
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
4591
_bz_scalb<double,int> >(_bz_ArrayExprConstant<double>(d1), d2);
4592
}
4593
4594
template<class T_numtype2, int N_rank2>
4595
inline
4596
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
4597
_bz_scalb<long double,T_numtype2> > >
4598
scalb(long double d1, const Array<T_numtype2, N_rank2>& d2)
4599
{
4600
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
4601
_bz_scalb<long double,T_numtype2> >(_bz_ArrayExprConstant<long double>(d1), d2.begin());
4602
}
4603
4604
template<class P_expr2>
4605
inline
4606
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
4607
_bz_scalb<long double,typename P_expr2::T_numtype> > >
4608
scalb(long double d1, _bz_ArrayExpr<P_expr2> d2)
4609
{
4610
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
4611
_bz_scalb<long double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<long double>(d1), d2);
4612
}
4613
4614
template<int N_index2>
4615
inline
4616
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
4617
_bz_scalb<long double,int> > >
4618
scalb(long double d1, IndexPlaceholder<N_index2> d2)
4619
{
4620
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
4621
_bz_scalb<long double,int> >(_bz_ArrayExprConstant<long double>(d1), d2);
4622
}
4623
4624
#ifdef BZ_HAVE_COMPLEX
4625
template<class T1, class T_numtype2, int N_rank2>
4626
inline
4627
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
4628
_bz_scalb<complex<T1> ,T_numtype2> > >
4629
scalb(complex<T1> d1, const Array<T_numtype2, N_rank2>& d2)
4630
{
4631
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
4632
_bz_scalb<complex<T1> ,T_numtype2> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2.begin());
4633
}
4634
4635
#endif // BZ_HAVE_COMPLEX
4636
4637
#ifdef BZ_HAVE_COMPLEX
4638
template<class T1, class P_expr2>
4639
inline
4640
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
4641
_bz_scalb<complex<T1> ,typename P_expr2::T_numtype> > >
4642
scalb(complex<T1> d1, _bz_ArrayExpr<P_expr2> d2)
4643
{
4644
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
4645
_bz_scalb<complex<T1> ,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
4646
}
4647
4648
#endif // BZ_HAVE_COMPLEX
4649
4650
#ifdef BZ_HAVE_COMPLEX
4651
template<class T1, int N_index2>
4652
inline
4653
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
4654
_bz_scalb<complex<T1> ,int> > >
4655
scalb(complex<T1> d1, IndexPlaceholder<N_index2> d2)
4656
{
4657
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
4658
_bz_scalb<complex<T1> ,int> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
4659
}
4660
4661
#endif // BZ_HAVE_COMPLEX
4662
4663
#endif
4664
4665
/****************************************************************************
4666
* sin
4667
****************************************************************************/
4668
4669
template<class T_numtype1, int N_rank1>
4670
inline
4671
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4672
_bz_sin<T_numtype1> > >
4673
sin(const Array<T_numtype1, N_rank1>& d1)
4674
{
4675
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4676
_bz_sin<T_numtype1> >(d1.begin());
4677
}
4678
4679
template<class P_expr1>
4680
inline
4681
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4682
_bz_sin<typename P_expr1::T_numtype> > >
4683
sin(_bz_ArrayExpr<P_expr1> d1)
4684
{
4685
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4686
_bz_sin<typename P_expr1::T_numtype> >(d1);
4687
}
4688
4689
template<int N_index1>
4690
inline
4691
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4692
_bz_sin<int> > >
4693
sin(IndexPlaceholder<N_index1> d1)
4694
{
4695
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4696
_bz_sin<int> >(d1);
4697
}
4698
4699
4700
/****************************************************************************
4701
* sinh
4702
****************************************************************************/
4703
4704
template<class T_numtype1, int N_rank1>
4705
inline
4706
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4707
_bz_sinh<T_numtype1> > >
4708
sinh(const Array<T_numtype1, N_rank1>& d1)
4709
{
4710
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4711
_bz_sinh<T_numtype1> >(d1.begin());
4712
}
4713
4714
template<class P_expr1>
4715
inline
4716
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4717
_bz_sinh<typename P_expr1::T_numtype> > >
4718
sinh(_bz_ArrayExpr<P_expr1> d1)
4719
{
4720
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4721
_bz_sinh<typename P_expr1::T_numtype> >(d1);
4722
}
4723
4724
template<int N_index1>
4725
inline
4726
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4727
_bz_sinh<int> > >
4728
sinh(IndexPlaceholder<N_index1> d1)
4729
{
4730
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4731
_bz_sinh<int> >(d1);
4732
}
4733
4734
4735
/****************************************************************************
4736
* sqr
4737
****************************************************************************/
4738
4739
template<class T_numtype1, int N_rank1>
4740
inline
4741
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4742
_bz_sqr<T_numtype1> > >
4743
sqr(const Array<T_numtype1, N_rank1>& d1)
4744
{
4745
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4746
_bz_sqr<T_numtype1> >(d1.begin());
4747
}
4748
4749
template<class P_expr1>
4750
inline
4751
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4752
_bz_sqr<typename P_expr1::T_numtype> > >
4753
sqr(_bz_ArrayExpr<P_expr1> d1)
4754
{
4755
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4756
_bz_sqr<typename P_expr1::T_numtype> >(d1);
4757
}
4758
4759
template<int N_index1>
4760
inline
4761
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4762
_bz_sqr<int> > >
4763
sqr(IndexPlaceholder<N_index1> d1)
4764
{
4765
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4766
_bz_sqr<int> >(d1);
4767
}
4768
4769
4770
/****************************************************************************
4771
* sqrt
4772
****************************************************************************/
4773
4774
template<class T_numtype1, int N_rank1>
4775
inline
4776
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4777
_bz_sqrt<T_numtype1> > >
4778
sqrt(const Array<T_numtype1, N_rank1>& d1)
4779
{
4780
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4781
_bz_sqrt<T_numtype1> >(d1.begin());
4782
}
4783
4784
template<class P_expr1>
4785
inline
4786
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4787
_bz_sqrt<typename P_expr1::T_numtype> > >
4788
sqrt(_bz_ArrayExpr<P_expr1> d1)
4789
{
4790
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4791
_bz_sqrt<typename P_expr1::T_numtype> >(d1);
4792
}
4793
4794
template<int N_index1>
4795
inline
4796
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4797
_bz_sqrt<int> > >
4798
sqrt(IndexPlaceholder<N_index1> d1)
4799
{
4800
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4801
_bz_sqrt<int> >(d1);
4802
}
4803
4804
4805
/****************************************************************************
4806
* tan
4807
****************************************************************************/
4808
4809
template<class T_numtype1, int N_rank1>
4810
inline
4811
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4812
_bz_tan<T_numtype1> > >
4813
tan(const Array<T_numtype1, N_rank1>& d1)
4814
{
4815
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4816
_bz_tan<T_numtype1> >(d1.begin());
4817
}
4818
4819
template<class P_expr1>
4820
inline
4821
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4822
_bz_tan<typename P_expr1::T_numtype> > >
4823
tan(_bz_ArrayExpr<P_expr1> d1)
4824
{
4825
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4826
_bz_tan<typename P_expr1::T_numtype> >(d1);
4827
}
4828
4829
template<int N_index1>
4830
inline
4831
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4832
_bz_tan<int> > >
4833
tan(IndexPlaceholder<N_index1> d1)
4834
{
4835
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4836
_bz_tan<int> >(d1);
4837
}
4838
4839
4840
/****************************************************************************
4841
* tanh
4842
****************************************************************************/
4843
4844
template<class T_numtype1, int N_rank1>
4845
inline
4846
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4847
_bz_tanh<T_numtype1> > >
4848
tanh(const Array<T_numtype1, N_rank1>& d1)
4849
{
4850
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4851
_bz_tanh<T_numtype1> >(d1.begin());
4852
}
4853
4854
template<class P_expr1>
4855
inline
4856
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4857
_bz_tanh<typename P_expr1::T_numtype> > >
4858
tanh(_bz_ArrayExpr<P_expr1> d1)
4859
{
4860
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4861
_bz_tanh<typename P_expr1::T_numtype> >(d1);
4862
}
4863
4864
template<int N_index1>
4865
inline
4866
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4867
_bz_tanh<int> > >
4868
tanh(IndexPlaceholder<N_index1> d1)
4869
{
4870
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4871
_bz_tanh<int> >(d1);
4872
}
4873
4874
4875
/****************************************************************************
4876
* uitrunc
4877
****************************************************************************/
4878
4879
#ifdef BZ_HAVE_SYSTEM_V_MATH
4880
template<class T_numtype1, int N_rank1>
4881
inline
4882
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4883
_bz_uitrunc<T_numtype1> > >
4884
uitrunc(const Array<T_numtype1, N_rank1>& d1)
4885
{
4886
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
4887
_bz_uitrunc<T_numtype1> >(d1.begin());
4888
}
4889
4890
template<class P_expr1>
4891
inline
4892
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4893
_bz_uitrunc<typename P_expr1::T_numtype> > >
4894
uitrunc(_bz_ArrayExpr<P_expr1> d1)
4895
{
4896
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
4897
_bz_uitrunc<typename P_expr1::T_numtype> >(d1);
4898
}
4899
4900
template<int N_index1>
4901
inline
4902
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4903
_bz_uitrunc<int> > >
4904
uitrunc(IndexPlaceholder<N_index1> d1)
4905
{
4906
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
4907
_bz_uitrunc<int> >(d1);
4908
}
4909
4910
#endif
4911
4912
/****************************************************************************
4913
* unordered
4914
****************************************************************************/
4915
4916
#ifdef BZ_HAVE_SYSTEM_V_MATH
4917
template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>
4918
inline
4919
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
4920
_bz_unordered<T_numtype1,T_numtype2> > >
4921
unordered(const Array<T_numtype1, N_rank1>& d1, const Array<T_numtype2, N_rank2>& d2)
4922
{
4923
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, ArrayIterator<T_numtype2, N_rank2>,
4924
_bz_unordered<T_numtype1,T_numtype2> >(d1.begin(), d2.begin());
4925
}
4926
4927
template<class T_numtype1, int N_rank1, class P_expr2>
4928
inline
4929
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
4930
_bz_unordered<T_numtype1,typename P_expr2::T_numtype> > >
4931
unordered(const Array<T_numtype1, N_rank1>& d1, _bz_ArrayExpr<P_expr2> d2)
4932
{
4933
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExpr<P_expr2>,
4934
_bz_unordered<T_numtype1,typename P_expr2::T_numtype> >(d1.begin(), d2);
4935
}
4936
4937
template<class T_numtype1, int N_rank1, int N_index2>
4938
inline
4939
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
4940
_bz_unordered<T_numtype1,int> > >
4941
unordered(const Array<T_numtype1, N_rank1>& d1, IndexPlaceholder<N_index2> d2)
4942
{
4943
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, IndexPlaceholder<N_index2>,
4944
_bz_unordered<T_numtype1,int> >(d1.begin(), d2);
4945
}
4946
4947
template<class T_numtype1, int N_rank1>
4948
inline
4949
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
4950
_bz_unordered<T_numtype1,float> > >
4951
unordered(const Array<T_numtype1, N_rank1>& d1, float d2)
4952
{
4953
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<float>,
4954
_bz_unordered<T_numtype1,float> >(d1.begin(), _bz_ArrayExprConstant<float>(d2));
4955
}
4956
4957
template<class T_numtype1, int N_rank1>
4958
inline
4959
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
4960
_bz_unordered<T_numtype1,double> > >
4961
unordered(const Array<T_numtype1, N_rank1>& d1, double d2)
4962
{
4963
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<double>,
4964
_bz_unordered<T_numtype1,double> >(d1.begin(), _bz_ArrayExprConstant<double>(d2));
4965
}
4966
4967
template<class T_numtype1, int N_rank1>
4968
inline
4969
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
4970
_bz_unordered<T_numtype1,long double> > >
4971
unordered(const Array<T_numtype1, N_rank1>& d1, long double d2)
4972
{
4973
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<long double>,
4974
_bz_unordered<T_numtype1,long double> >(d1.begin(), _bz_ArrayExprConstant<long double>(d2));
4975
}
4976
4977
#ifdef BZ_HAVE_COMPLEX
4978
template<class T_numtype1, int N_rank1, class T2>
4979
inline
4980
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
4981
_bz_unordered<T_numtype1,complex<T2> > > >
4982
unordered(const Array<T_numtype1, N_rank1>& d1, complex<T2> d2)
4983
{
4984
return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, _bz_ArrayExprConstant<complex<T2> > ,
4985
_bz_unordered<T_numtype1,complex<T2> > >(d1.begin(), _bz_ArrayExprConstant<complex<T2> > (d2));
4986
}
4987
4988
#endif // BZ_HAVE_COMPLEX
4989
4990
template<class P_expr1, class T_numtype2, int N_rank2>
4991
inline
4992
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
4993
_bz_unordered<typename P_expr1::T_numtype,T_numtype2> > >
4994
unordered(_bz_ArrayExpr<P_expr1> d1, const Array<T_numtype2, N_rank2>& d2)
4995
{
4996
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, ArrayIterator<T_numtype2, N_rank2>,
4997
_bz_unordered<typename P_expr1::T_numtype,T_numtype2> >(d1, d2.begin());
4998
}
4999
5000
template<class P_expr1, class P_expr2>
5001
inline
5002
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
5003
_bz_unordered<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
5004
unordered(_bz_ArrayExpr<P_expr1> d1, _bz_ArrayExpr<P_expr2> d2)
5005
{
5006
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExpr<P_expr2>,
5007
_bz_unordered<typename P_expr1::T_numtype,typename P_expr2::T_numtype> >(d1, d2);
5008
}
5009
5010
template<class P_expr1, int N_index2>
5011
inline
5012
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
5013
_bz_unordered<typename P_expr1::T_numtype,int> > >
5014
unordered(_bz_ArrayExpr<P_expr1> d1, IndexPlaceholder<N_index2> d2)
5015
{
5016
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, IndexPlaceholder<N_index2>,
5017
_bz_unordered<typename P_expr1::T_numtype,int> >(d1, d2);
5018
}
5019
5020
template<class P_expr1>
5021
inline
5022
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
5023
_bz_unordered<typename P_expr1::T_numtype,float> > >
5024
unordered(_bz_ArrayExpr<P_expr1> d1, float d2)
5025
{
5026
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<float>,
5027
_bz_unordered<typename P_expr1::T_numtype,float> >(d1, _bz_ArrayExprConstant<float>(d2));
5028
}
5029
5030
template<class P_expr1>
5031
inline
5032
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
5033
_bz_unordered<typename P_expr1::T_numtype,double> > >
5034
unordered(_bz_ArrayExpr<P_expr1> d1, double d2)
5035
{
5036
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<double>,
5037
_bz_unordered<typename P_expr1::T_numtype,double> >(d1, _bz_ArrayExprConstant<double>(d2));
5038
}
5039
5040
template<class P_expr1>
5041
inline
5042
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
5043
_bz_unordered<typename P_expr1::T_numtype,long double> > >
5044
unordered(_bz_ArrayExpr<P_expr1> d1, long double d2)
5045
{
5046
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<long double>,
5047
_bz_unordered<typename P_expr1::T_numtype,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
5048
}
5049
5050
#ifdef BZ_HAVE_COMPLEX
5051
template<class P_expr1, class T2>
5052
inline
5053
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
5054
_bz_unordered<typename P_expr1::T_numtype,complex<T2> > > >
5055
unordered(_bz_ArrayExpr<P_expr1> d1, complex<T2> d2)
5056
{
5057
return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, _bz_ArrayExprConstant<complex<T2> > ,
5058
_bz_unordered<typename P_expr1::T_numtype,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
5059
}
5060
5061
#endif // BZ_HAVE_COMPLEX
5062
5063
template<int N_index1, class T_numtype2, int N_rank2>
5064
inline
5065
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
5066
_bz_unordered<int,T_numtype2> > >
5067
unordered(IndexPlaceholder<N_index1> d1, const Array<T_numtype2, N_rank2>& d2)
5068
{
5069
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, ArrayIterator<T_numtype2, N_rank2>,
5070
_bz_unordered<int,T_numtype2> >(d1, d2.begin());
5071
}
5072
5073
template<int N_index1, class P_expr2>
5074
inline
5075
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
5076
_bz_unordered<int,typename P_expr2::T_numtype> > >
5077
unordered(IndexPlaceholder<N_index1> d1, _bz_ArrayExpr<P_expr2> d2)
5078
{
5079
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExpr<P_expr2>,
5080
_bz_unordered<int,typename P_expr2::T_numtype> >(d1, d2);
5081
}
5082
5083
template<int N_index1, int N_index2>
5084
inline
5085
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
5086
_bz_unordered<int,int> > >
5087
unordered(IndexPlaceholder<N_index1> d1, IndexPlaceholder<N_index2> d2)
5088
{
5089
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, IndexPlaceholder<N_index2>,
5090
_bz_unordered<int,int> >(d1, d2);
5091
}
5092
5093
template<int N_index1>
5094
inline
5095
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
5096
_bz_unordered<int,float> > >
5097
unordered(IndexPlaceholder<N_index1> d1, float d2)
5098
{
5099
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<float>,
5100
_bz_unordered<int,float> >(d1, _bz_ArrayExprConstant<float>(d2));
5101
}
5102
5103
template<int N_index1>
5104
inline
5105
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
5106
_bz_unordered<int,double> > >
5107
unordered(IndexPlaceholder<N_index1> d1, double d2)
5108
{
5109
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<double>,
5110
_bz_unordered<int,double> >(d1, _bz_ArrayExprConstant<double>(d2));
5111
}
5112
5113
template<int N_index1>
5114
inline
5115
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
5116
_bz_unordered<int,long double> > >
5117
unordered(IndexPlaceholder<N_index1> d1, long double d2)
5118
{
5119
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<long double>,
5120
_bz_unordered<int,long double> >(d1, _bz_ArrayExprConstant<long double>(d2));
5121
}
5122
5123
#ifdef BZ_HAVE_COMPLEX
5124
template<int N_index1, class T2>
5125
inline
5126
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
5127
_bz_unordered<int,complex<T2> > > >
5128
unordered(IndexPlaceholder<N_index1> d1, complex<T2> d2)
5129
{
5130
return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, _bz_ArrayExprConstant<complex<T2> > ,
5131
_bz_unordered<int,complex<T2> > >(d1, _bz_ArrayExprConstant<complex<T2> > (d2));
5132
}
5133
5134
#endif // BZ_HAVE_COMPLEX
5135
5136
template<class T_numtype2, int N_rank2>
5137
inline
5138
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
5139
_bz_unordered<float,T_numtype2> > >
5140
unordered(float d1, const Array<T_numtype2, N_rank2>& d2)
5141
{
5142
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, ArrayIterator<T_numtype2, N_rank2>,
5143
_bz_unordered<float,T_numtype2> >(_bz_ArrayExprConstant<float>(d1), d2.begin());
5144
}
5145
5146
template<class P_expr2>
5147
inline
5148
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
5149
_bz_unordered<float,typename P_expr2::T_numtype> > >
5150
unordered(float d1, _bz_ArrayExpr<P_expr2> d2)
5151
{
5152
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, _bz_ArrayExpr<P_expr2>,
5153
_bz_unordered<float,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<float>(d1), d2);
5154
}
5155
5156
template<int N_index2>
5157
inline
5158
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
5159
_bz_unordered<float,int> > >
5160
unordered(float d1, IndexPlaceholder<N_index2> d2)
5161
{
5162
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, IndexPlaceholder<N_index2>,
5163
_bz_unordered<float,int> >(_bz_ArrayExprConstant<float>(d1), d2);
5164
}
5165
5166
template<class T_numtype2, int N_rank2>
5167
inline
5168
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
5169
_bz_unordered<double,T_numtype2> > >
5170
unordered(double d1, const Array<T_numtype2, N_rank2>& d2)
5171
{
5172
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, ArrayIterator<T_numtype2, N_rank2>,
5173
_bz_unordered<double,T_numtype2> >(_bz_ArrayExprConstant<double>(d1), d2.begin());
5174
}
5175
5176
template<class P_expr2>
5177
inline
5178
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
5179
_bz_unordered<double,typename P_expr2::T_numtype> > >
5180
unordered(double d1, _bz_ArrayExpr<P_expr2> d2)
5181
{
5182
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, _bz_ArrayExpr<P_expr2>,
5183
_bz_unordered<double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<double>(d1), d2);
5184
}
5185
5186
template<int N_index2>
5187
inline
5188
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
5189
_bz_unordered<double,int> > >
5190
unordered(double d1, IndexPlaceholder<N_index2> d2)
5191
{
5192
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, IndexPlaceholder<N_index2>,
5193
_bz_unordered<double,int> >(_bz_ArrayExprConstant<double>(d1), d2);
5194
}
5195
5196
template<class T_numtype2, int N_rank2>
5197
inline
5198
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
5199
_bz_unordered<long double,T_numtype2> > >
5200
unordered(long double d1, const Array<T_numtype2, N_rank2>& d2)
5201
{
5202
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, ArrayIterator<T_numtype2, N_rank2>,
5203
_bz_unordered<long double,T_numtype2> >(_bz_ArrayExprConstant<long double>(d1), d2.begin());
5204
}
5205
5206
template<class P_expr2>
5207
inline
5208
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
5209
_bz_unordered<long double,typename P_expr2::T_numtype> > >
5210
unordered(long double d1, _bz_ArrayExpr<P_expr2> d2)
5211
{
5212
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, _bz_ArrayExpr<P_expr2>,
5213
_bz_unordered<long double,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<long double>(d1), d2);
5214
}
5215
5216
template<int N_index2>
5217
inline
5218
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
5219
_bz_unordered<long double,int> > >
5220
unordered(long double d1, IndexPlaceholder<N_index2> d2)
5221
{
5222
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, IndexPlaceholder<N_index2>,
5223
_bz_unordered<long double,int> >(_bz_ArrayExprConstant<long double>(d1), d2);
5224
}
5225
5226
#ifdef BZ_HAVE_COMPLEX
5227
template<class T1, class T_numtype2, int N_rank2>
5228
inline
5229
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
5230
_bz_unordered<complex<T1> ,T_numtype2> > >
5231
unordered(complex<T1> d1, const Array<T_numtype2, N_rank2>& d2)
5232
{
5233
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , ArrayIterator<T_numtype2, N_rank2>,
5234
_bz_unordered<complex<T1> ,T_numtype2> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2.begin());
5235
}
5236
5237
#endif // BZ_HAVE_COMPLEX
5238
5239
#ifdef BZ_HAVE_COMPLEX
5240
template<class T1, class P_expr2>
5241
inline
5242
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
5243
_bz_unordered<complex<T1> ,typename P_expr2::T_numtype> > >
5244
unordered(complex<T1> d1, _bz_ArrayExpr<P_expr2> d2)
5245
{
5246
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , _bz_ArrayExpr<P_expr2>,
5247
_bz_unordered<complex<T1> ,typename P_expr2::T_numtype> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
5248
}
5249
5250
#endif // BZ_HAVE_COMPLEX
5251
5252
#ifdef BZ_HAVE_COMPLEX
5253
template<class T1, int N_index2>
5254
inline
5255
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
5256
_bz_unordered<complex<T1> ,int> > >
5257
unordered(complex<T1> d1, IndexPlaceholder<N_index2> d2)
5258
{
5259
return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , IndexPlaceholder<N_index2>,
5260
_bz_unordered<complex<T1> ,int> >(_bz_ArrayExprConstant<complex<T1> > (d1), d2);
5261
}
5262
5263
#endif // BZ_HAVE_COMPLEX
5264
5265
#endif
5266
5267
/****************************************************************************
5268
* y0
5269
****************************************************************************/
5270
5271
#ifdef BZ_HAVE_IEEE_MATH
5272
template<class T_numtype1, int N_rank1>
5273
inline
5274
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
5275
_bz_y0<T_numtype1> > >
5276
y0(const Array<T_numtype1, N_rank1>& d1)
5277
{
5278
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
5279
_bz_y0<T_numtype1> >(d1.begin());
5280
}
5281
5282
template<class P_expr1>
5283
inline
5284
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
5285
_bz_y0<typename P_expr1::T_numtype> > >
5286
y0(_bz_ArrayExpr<P_expr1> d1)
5287
{
5288
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
5289
_bz_y0<typename P_expr1::T_numtype> >(d1);
5290
}
5291
5292
template<int N_index1>
5293
inline
5294
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
5295
_bz_y0<int> > >
5296
y0(IndexPlaceholder<N_index1> d1)
5297
{
5298
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
5299
_bz_y0<int> >(d1);
5300
}
5301
5302
#endif
5303
5304
/****************************************************************************
5305
* y1
5306
****************************************************************************/
5307
5308
#ifdef BZ_HAVE_IEEE_MATH
5309
template<class T_numtype1, int N_rank1>
5310
inline
5311
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
5312
_bz_y1<T_numtype1> > >
5313
y1(const Array<T_numtype1, N_rank1>& d1)
5314
{
5315
return _bz_ArrayExprUnaryOp<ArrayIterator<T_numtype1, N_rank1>,
5316
_bz_y1<T_numtype1> >(d1.begin());
5317
}
5318
5319
template<class P_expr1>
5320
inline
5321
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
5322
_bz_y1<typename P_expr1::T_numtype> > >
5323
y1(_bz_ArrayExpr<P_expr1> d1)
5324
{
5325
return _bz_ArrayExprUnaryOp<_bz_ArrayExpr<P_expr1>,
5326
_bz_y1<typename P_expr1::T_numtype> >(d1);
5327
}
5328
5329
template<int N_index1>
5330
inline
5331
_bz_ArrayExpr<_bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
5332
_bz_y1<int> > >
5333
y1(IndexPlaceholder<N_index1> d1)
5334
{
5335
return _bz_ArrayExprUnaryOp<IndexPlaceholder<N_index1>,
5336
_bz_y1<int> >(d1);
5337
}
5338
5339
#endif
5340
5341
BZ_NAMESPACE_END
5342
5343
#endif
Loggerhead is a web-based interface for Breezy
Version: 2.0.1