Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

uops.cc@ 463

Visit:

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

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

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

Context Navigation

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

Download in other formats: