Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

uops.cc@ 221

Visit:

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

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

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

Context Navigation

source: Sophya/trunk/SophyaExt/Blitz/blitz/array/uops.cc@ 221

Download in other formats: