Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

uops.cc@ 658

Visit:

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

Rev	Line
[658]	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@ 658

Download in other formats: