Context Navigation

source: XMLIO_V2/external/include/blitz/array/uops.cc @ 80

Last change on this file since 80 was 80, checked in by ymipsl, 14 years ago
ajout lib externe
File size: 190.8 KB

Line
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

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

Download in other formats: