/*************************************************************************** * blitz/../array/bops.cc	Array expression templates (2 operands) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * Suggestions:          blitz-suggest@cybervision.com * Bugs:                 blitz-bugs@cybervision.com * * For more information, please see the Blitz++ Home Page: *    http://seurat.uwaterloo.ca/blitz/ * *************************************************************************** * */ // Generated source file.  Do not edit. // genarrbops.cpp Dec 30 2003 16:48:46#ifndef BZ_ARRAYBOPS_CC#define BZ_ARRAYBOPS_CC#ifndef BZ_ARRAYEXPR_H #error <blitz/array/bops.cc> must be included after <blitz/arrayexpr.h>#endifBZ_NAMESPACE(blitz)/**************************************************************************** * Addition Operators ****************************************************************************/// Array<T_numtype1, N_rank1> + Array<T_numtype2, N_rank2>template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       ArrayIterator<T_numtype2, N_rank2>,      Add<T_numtype1, T_numtype2 > > >operator+(const Array<T_numtype1, N_rank1>& d1,       const Array<T_numtype2, N_rank2>& d2){    return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       ArrayIterator<T_numtype2, N_rank2>,       Add<T_numtype1, T_numtype2> >      (d1.begin(),       d2.begin());}// Array<T_numtype1, N_rank1> + _bz_ArrayExpr<P_expr2>template<class T_numtype1, int N_rank1, class P_expr2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExpr<P_expr2>,      Add<T_numtype1, typename P_expr2::T_numtype > > >operator+(const Array<T_numtype1, N_rank1>& d1,       _bz_ArrayExpr<P_expr2> d2){    return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExpr<P_expr2>,       Add<T_numtype1, typename P_expr2::T_numtype> >      (d1.begin(),       d2);}// Array<T_numtype1, N_rank1> + IndexPlaceholder<N_index2>template<class T_numtype1, int N_rank1, int N_index2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       IndexPlaceholder<N_index2>,      Add<T_numtype1, int > > >operator+(const Array<T_numtype1, N_rank1>& d1,       IndexPlaceholder<N_index2> d2){    return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       IndexPlaceholder<N_index2>,       Add<T_numtype1, int> >      (d1.begin(),       d2);}// Array<T_numtype1, N_rank1> + inttemplate<class T_numtype1, int N_rank1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExprConstant<int>,      Add<T_numtype1, int > > >operator+(const Array<T_numtype1, N_rank1>& d1,       int d2){    return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExprConstant<int>,       Add<T_numtype1, int> >      (d1.begin(),       _bz_ArrayExprConstant<int>(d2));}// Array<T_numtype1, N_rank1> + floattemplate<class T_numtype1, int N_rank1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExprConstant<float>,      Add<T_numtype1, float > > >operator+(const Array<T_numtype1, N_rank1>& d1,       float d2){    return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExprConstant<float>,       Add<T_numtype1, float> >      (d1.begin(),       _bz_ArrayExprConstant<float>(d2));}// Array<T_numtype1, N_rank1> + doubletemplate<class T_numtype1, int N_rank1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExprConstant<double>,      Add<T_numtype1, double > > >operator+(const Array<T_numtype1, N_rank1>& d1,       double d2){    return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExprConstant<double>,       Add<T_numtype1, double> >      (d1.begin(),       _bz_ArrayExprConstant<double>(d2));}// Array<T_numtype1, N_rank1> + long doubletemplate<class T_numtype1, int N_rank1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExprConstant<long double>,      Add<T_numtype1, long double > > >operator+(const Array<T_numtype1, N_rank1>& d1,       long double d2){    return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExprConstant<long double>,       Add<T_numtype1, long double> >      (d1.begin(),       _bz_ArrayExprConstant<long double>(d2));}#ifdef BZ_HAVE_COMPLEX// Array<T_numtype1, N_rank1> + complex<T2>template<class T_numtype1, int N_rank1, class T2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExprConstant<complex<T2> > ,      Add<T_numtype1, complex<T2>  > > >operator+(const Array<T_numtype1, N_rank1>& d1,       complex<T2> d2){    return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>,       _bz_ArrayExprConstant<complex<T2> > ,       Add<T_numtype1, complex<T2> > >      (d1.begin(),       _bz_ArrayExprConstant<complex<T2> > (d2));}#endif // BZ_HAVE_COMPLEX// _bz_ArrayExpr<P_expr1> + Array<T_numtype2, N_rank2>template<class P_expr1, class T_numtype2, int N_rank2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       ArrayIterator<T_numtype2, N_rank2>,      Add<typename P_expr1::T_numtype, T_numtype2 > > >operator+(_bz_ArrayExpr<P_expr1> d1,       const Array<T_numtype2, N_rank2>& d2){    return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       ArrayIterator<T_numtype2, N_rank2>,       Add<typename P_expr1::T_numtype, T_numtype2> >      (d1,       d2.begin());}// _bz_ArrayExpr<P_expr1> + _bz_ArrayExpr<P_expr2>template<class P_expr1, class P_expr2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExpr<P_expr2>,      Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >operator+(_bz_ArrayExpr<P_expr1> d1,       _bz_ArrayExpr<P_expr2> d2){    return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExpr<P_expr2>,       Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype> >      (d1,       d2);}// _bz_ArrayExpr<P_expr1> + IndexPlaceholder<N_index2>template<class P_expr1, int N_index2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       IndexPlaceholder<N_index2>,      Add<typename P_expr1::T_numtype, int > > >operator+(_bz_ArrayExpr<P_expr1> d1,       IndexPlaceholder<N_index2> d2){    return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       IndexPlaceholder<N_index2>,       Add<typename P_expr1::T_numtype, int> >      (d1,       d2);}// _bz_ArrayExpr<P_expr1> + inttemplate<class P_expr1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExprConstant<int>,      Add<typename P_expr1::T_numtype, int > > >operator+(_bz_ArrayExpr<P_expr1> d1,       int d2){    return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExprConstant<int>,       Add<typename P_expr1::T_numtype, int> >      (d1,       _bz_ArrayExprConstant<int>(d2));}// _bz_ArrayExpr<P_expr1> + floattemplate<class P_expr1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExprConstant<float>,      Add<typename P_expr1::T_numtype, float > > >operator+(_bz_ArrayExpr<P_expr1> d1,       float d2){    return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExprConstant<float>,       Add<typename P_expr1::T_numtype, float> >      (d1,       _bz_ArrayExprConstant<float>(d2));}// _bz_ArrayExpr<P_expr1> + doubletemplate<class P_expr1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExprConstant<double>,      Add<typename P_expr1::T_numtype, double > > >operator+(_bz_ArrayExpr<P_expr1> d1,       double d2){    return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExprConstant<double>,       Add<typename P_expr1::T_numtype, double> >      (d1,       _bz_ArrayExprConstant<double>(d2));}// _bz_ArrayExpr<P_expr1> + long doubletemplate<class P_expr1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExprConstant<long double>,      Add<typename P_expr1::T_numtype, long double > > >operator+(_bz_ArrayExpr<P_expr1> d1,       long double d2){    return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExprConstant<long double>,       Add<typename P_expr1::T_numtype, long double> >      (d1,       _bz_ArrayExprConstant<long double>(d2));}#ifdef BZ_HAVE_COMPLEX// _bz_ArrayExpr<P_expr1> + complex<T2>template<class P_expr1, class T2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExprConstant<complex<T2> > ,      Add<typename P_expr1::T_numtype, complex<T2>  > > >operator+(_bz_ArrayExpr<P_expr1> d1,       complex<T2> d2){    return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>,       _bz_ArrayExprConstant<complex<T2> > ,       Add<typename P_expr1::T_numtype, complex<T2> > >      (d1,       _bz_ArrayExprConstant<complex<T2> > (d2));}#endif // BZ_HAVE_COMPLEX// IndexPlaceholder<N_index1> + Array<T_numtype2, N_rank2>template<int N_index1, class T_numtype2, int N_rank2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       ArrayIterator<T_numtype2, N_rank2>,      Add<int, T_numtype2 > > >operator+(IndexPlaceholder<N_index1> d1,       const Array<T_numtype2, N_rank2>& d2){    return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       ArrayIterator<T_numtype2, N_rank2>,       Add<int, T_numtype2> >      (d1,       d2.begin());}// IndexPlaceholder<N_index1> + _bz_ArrayExpr<P_expr2>template<int N_index1, class P_expr2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExpr<P_expr2>,      Add<int, typename P_expr2::T_numtype > > >operator+(IndexPlaceholder<N_index1> d1,       _bz_ArrayExpr<P_expr2> d2){    return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExpr<P_expr2>,       Add<int, typename P_expr2::T_numtype> >      (d1,       d2);}// IndexPlaceholder<N_index1> + IndexPlaceholder<N_index2>template<int N_index1, int N_index2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       IndexPlaceholder<N_index2>,      Add<int, int > > >operator+(IndexPlaceholder<N_index1> d1,       IndexPlaceholder<N_index2> d2){    return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       IndexPlaceholder<N_index2>,       Add<int, int> >      (d1,       d2);}// IndexPlaceholder<N_index1> + inttemplate<int N_index1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExprConstant<int>,      Add<int, int > > >operator+(IndexPlaceholder<N_index1> d1,       int d2){    return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExprConstant<int>,       Add<int, int> >      (d1,       _bz_ArrayExprConstant<int>(d2));}// IndexPlaceholder<N_index1> + floattemplate<int N_index1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExprConstant<float>,      Add<int, float > > >operator+(IndexPlaceholder<N_index1> d1,       float d2){    return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExprConstant<float>,       Add<int, float> >      (d1,       _bz_ArrayExprConstant<float>(d2));}// IndexPlaceholder<N_index1> + doubletemplate<int N_index1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExprConstant<double>,      Add<int, double > > >operator+(IndexPlaceholder<N_index1> d1,       double d2){    return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExprConstant<double>,       Add<int, double> >      (d1,       _bz_ArrayExprConstant<double>(d2));}// IndexPlaceholder<N_index1> + long doubletemplate<int N_index1>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExprConstant<long double>,      Add<int, long double > > >operator+(IndexPlaceholder<N_index1> d1,       long double d2){    return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExprConstant<long double>,       Add<int, long double> >      (d1,       _bz_ArrayExprConstant<long double>(d2));}#ifdef BZ_HAVE_COMPLEX// IndexPlaceholder<N_index1> + complex<T2>template<int N_index1, class T2>inline_bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>,       _bz_ArrayExprConstant<complex<T2> > ,