Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

uops.cc@ 3517

Visit:

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

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

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

Context Navigation

source: Sophya/trunk/Poubelle/DPC:FitsIOServer/Blitz/blitz/array/uops.cc@ 3517

Download in other formats: