| bops.cc | | bops.cc | |
| /**************************************************************************
* | | /**************************************************************************
* | |
|
| * blitz/arraybops.cc Array expression templates (2 operands) | | * blitz/../array/bops.cc Array expression templates (2 operands) | |
| * | | * | |
|
| * $Id: bops.cc,v 1.1.1.1 2000/06/19 12:26:14 tveldhui Exp $ | | * 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. | |
| * | | * | |
|
| * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org> | | * This program is distributed in the hope that it will be useful, | |
| * All rights reserved. Please see <blitz/blitz.h> for terms and | | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * conditions of use. | | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| | | * GNU General Public License for more details. | |
| * | | * | |
|
| * Suggestions: blitz-dev@oonumerics.org | | * Suggestions: blitz-suggest@cybervision.com | |
| * Bugs: blitz-bugs@oonumerics.org | | * Bugs: blitz-bugs@cybervision.com | |
| * | | * | |
| * For more information, please see the Blitz++ Home Page: | | * For more information, please see the Blitz++ Home Page: | |
|
| * http://oonumerics.org/blitz/ | | * http://seurat.uwaterloo.ca/blitz/ | |
| * | | * | |
| **************************************************************************
* | | **************************************************************************
* | |
|
| * $Log: bops.cc,v $ | | | |
| * Revision 1.1.1.1 2000/06/19 12:26:14 tveldhui | | | |
| * Imported sources | | | |
| * | | | |
| * Revision 1.2 1998/03/14 00:04:47 tveldhui | | | |
| * 0.2-alpha-05 | | | |
| * | | * | |
| */ | | */ | |
| | | | |
| // Generated source file. Do not edit. | | // Generated source file. Do not edit. | |
|
| // genarrbops.cpp Aug 7 1997 15:04:14 | | // genarrbops.cpp Dec 30 2003 16:48:46 | |
| | | | |
| #ifndef BZ_ARRAYBOPS_CC | | #ifndef BZ_ARRAYBOPS_CC | |
| #define BZ_ARRAYBOPS_CC | | #define BZ_ARRAYBOPS_CC | |
| | | | |
| #ifndef BZ_ARRAYEXPR_H | | #ifndef BZ_ARRAYEXPR_H | |
|
| #error <blitz/arraybops.cc> must be included after <blitz/arrayexpr.h> | | #error <blitz/array/bops.cc> must be included after <blitz/arrayexpr.h> | |
| #endif | | #endif | |
| | | | |
| BZ_NAMESPACE(blitz) | | BZ_NAMESPACE(blitz) | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Addition Operators | | * Addition Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> + Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> + Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<T_numtype1, T_numtype2 > > > | | Add<T_numtype1, T_numtype2 > > > | |
| operator+(const Array<T_numtype1, N_rank1>& d1, | | operator+(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<T_numtype1, T_numtype2> > | | Add<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> + _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> + _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | Add<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator+(const Array<T_numtype1, N_rank1>& d1, | | operator+(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<T_numtype1, _bz_typename P_expr2::T_numtype> > | | Add<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> + IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> + IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<T_numtype1, int > > > | | Add<T_numtype1, int > > > | |
| operator+(const Array<T_numtype1, N_rank1>& d1, | | operator+(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<T_numtype1, int> > | | Add<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> + int | | // Array<T_numtype1, N_rank1> + int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Add<T_numtype1, int > > > | | Add<T_numtype1, int > > > | |
| operator+(const Array<T_numtype1, N_rank1>& d1, | | operator+(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Add<T_numtype1, int> > | | Add<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> + float | | // Array<T_numtype1, N_rank1> + float | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Add<T_numtype1, float > > > | | Add<T_numtype1, float > > > | |
| operator+(const Array<T_numtype1, N_rank1>& d1, | | operator+(const Array<T_numtype1, N_rank1>& d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Add<T_numtype1, float> > | | Add<T_numtype1, float> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> + double | | // Array<T_numtype1, N_rank1> + double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Add<T_numtype1, double > > > | | Add<T_numtype1, double > > > | |
| operator+(const Array<T_numtype1, N_rank1>& d1, | | operator+(const Array<T_numtype1, N_rank1>& d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Add<T_numtype1, double> > | | Add<T_numtype1, double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> + long double | | // Array<T_numtype1, N_rank1> + long double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Add<T_numtype1, long double > > > | | Add<T_numtype1, long double > > > | |
| operator+(const Array<T_numtype1, N_rank1>& d1, | | operator+(const Array<T_numtype1, N_rank1>& d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Add<T_numtype1, long double> > | | Add<T_numtype1, long double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // Array<T_numtype1, N_rank1> + complex<T2> | | // Array<T_numtype1, N_rank1> + complex<T2> | |
| template<class T_numtype1, int N_rank1, class T2> | | template<class T_numtype1, int N_rank1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Add<T_numtype1, complex<T2> > > > | | Add<T_numtype1, complex<T2> > > > | |
| operator+(const Array<T_numtype1, N_rank1>& d1, | | operator+(const Array<T_numtype1, N_rank1>& d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Add<T_numtype1, complex<T2> > > | | Add<T_numtype1, complex<T2> > > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_ArrayExpr<P_expr1> + Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> + Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Add<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | Add<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator+(_bz_ArrayExpr<P_expr1> d1, | | operator+(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Add<_bz_typename P_expr1::T_numtype, T_numtype2> > | | Add<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> + _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> + _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numtype
> > > | | Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > > | |
| operator+(_bz_ArrayExpr<P_expr1> d1, | | operator+(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numtype>
> | | Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> + IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> + IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Add<_bz_typename P_expr1::T_numtype, int > > > | | Add<typename P_expr1::T_numtype, int > > > | |
| operator+(_bz_ArrayExpr<P_expr1> d1, | | operator+(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Add<_bz_typename P_expr1::T_numtype, int> > | | Add<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> + int | | // _bz_ArrayExpr<P_expr1> + int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Add<_bz_typename P_expr1::T_numtype, int > > > | | Add<typename P_expr1::T_numtype, int > > > | |
| operator+(_bz_ArrayExpr<P_expr1> d1, | | operator+(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Add<_bz_typename P_expr1::T_numtype, int> > | | Add<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> + float | | // _bz_ArrayExpr<P_expr1> + float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Add<_bz_typename P_expr1::T_numtype, float > > > | | Add<typename P_expr1::T_numtype, float > > > | |
| operator+(_bz_ArrayExpr<P_expr1> d1, | | operator+(_bz_ArrayExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Add<_bz_typename P_expr1::T_numtype, float> > | | Add<typename P_expr1::T_numtype, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> + double | | // _bz_ArrayExpr<P_expr1> + double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Add<_bz_typename P_expr1::T_numtype, double > > > | | Add<typename P_expr1::T_numtype, double > > > | |
| operator+(_bz_ArrayExpr<P_expr1> d1, | | operator+(_bz_ArrayExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Add<_bz_typename P_expr1::T_numtype, double> > | | Add<typename P_expr1::T_numtype, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> + long double | | // _bz_ArrayExpr<P_expr1> + long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Add<_bz_typename P_expr1::T_numtype, long double > > > | | Add<typename P_expr1::T_numtype, long double > > > | |
| operator+(_bz_ArrayExpr<P_expr1> d1, | | operator+(_bz_ArrayExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Add<_bz_typename P_expr1::T_numtype, long double> > | | Add<typename P_expr1::T_numtype, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // _bz_ArrayExpr<P_expr1> + complex<T2> | | // _bz_ArrayExpr<P_expr1> + complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Add<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | Add<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator+(_bz_ArrayExpr<P_expr1> d1, | | operator+(_bz_ArrayExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Add<_bz_typename P_expr1::T_numtype, complex<T2> > > | | Add<typename P_expr1::T_numtype, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // IndexPlaceholder<N_index1> + Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> + Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<int, T_numtype2 > > > | | Add<int, T_numtype2 > > > | |
| operator+(IndexPlaceholder<N_index1> d1, | | operator+(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<int, T_numtype2> > | | Add<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> + _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> + _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<int, _bz_typename P_expr2::T_numtype > > > | | Add<int, typename P_expr2::T_numtype > > > | |
| operator+(IndexPlaceholder<N_index1> d1, | | operator+(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<int, _bz_typename P_expr2::T_numtype> > | | Add<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> + IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> + IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<int, int > > > | | Add<int, int > > > | |
| operator+(IndexPlaceholder<N_index1> d1, | | operator+(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<int, int> > | | Add<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> + int | | // IndexPlaceholder<N_index1> + int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Add<int, int > > > | | Add<int, int > > > | |
| operator+(IndexPlaceholder<N_index1> d1, | | operator+(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Add<int, int> > | | Add<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> + float | | // IndexPlaceholder<N_index1> + float | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Add<int, float > > > | | Add<int, float > > > | |
| operator+(IndexPlaceholder<N_index1> d1, | | operator+(IndexPlaceholder<N_index1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Add<int, float> > | | Add<int, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> + double | | // IndexPlaceholder<N_index1> + double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Add<int, double > > > | | Add<int, double > > > | |
| operator+(IndexPlaceholder<N_index1> d1, | | operator+(IndexPlaceholder<N_index1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Add<int, double> > | | Add<int, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> + long double | | // IndexPlaceholder<N_index1> + long double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Add<int, long double > > > | | Add<int, long double > > > | |
| operator+(IndexPlaceholder<N_index1> d1, | | operator+(IndexPlaceholder<N_index1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Add<int, long double> > | | Add<int, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // IndexPlaceholder<N_index1> + complex<T2> | | // IndexPlaceholder<N_index1> + complex<T2> | |
| template<int N_index1, class T2> | | template<int N_index1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Add<int, complex<T2> > > > | | Add<int, complex<T2> > > > | |
| operator+(IndexPlaceholder<N_index1> d1, | | operator+(IndexPlaceholder<N_index1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Add<int, complex<T2> > > | | Add<int, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int + Array<T_numtype2, N_rank2> | | // int + Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<int, T_numtype2 > > > | | Add<int, T_numtype2 > > > | |
| operator+(int d1, | | operator+(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<int, T_numtype2> > | | Add<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int + _bz_ArrayExpr<P_expr2> | | // int + _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<int, _bz_typename P_expr2::T_numtype > > > | | Add<int, typename P_expr2::T_numtype > > > | |
| operator+(int d1, | | operator+(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<int, _bz_typename P_expr2::T_numtype> > | | Add<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int + IndexPlaceholder<N_index2> | | // int + IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<int, int > > > | | Add<int, int > > > | |
| operator+(int d1, | | operator+(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<int, int> > | | Add<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float + Array<T_numtype2, N_rank2> | | // float + Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<float, T_numtype2 > > > | | Add<float, T_numtype2 > > > | |
| operator+(float d1, | | operator+(float d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<float, T_numtype2> > | | Add<float, T_numtype2> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // float + _bz_ArrayExpr<P_expr2> | | // float + _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<float, _bz_typename P_expr2::T_numtype > > > | | Add<float, typename P_expr2::T_numtype > > > | |
| operator+(float d1, | | operator+(float d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<float, _bz_typename P_expr2::T_numtype> > | | Add<float, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float + IndexPlaceholder<N_index2> | | // float + IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<float, int > > > | | Add<float, int > > > | |
| operator+(float d1, | | operator+(float d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<float, int> > | | Add<float, int> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double + Array<T_numtype2, N_rank2> | | // double + Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<double, T_numtype2 > > > | | Add<double, T_numtype2 > > > | |
| operator+(double d1, | | operator+(double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<double, T_numtype2> > | | Add<double, T_numtype2> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // double + _bz_ArrayExpr<P_expr2> | | // double + _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<double, _bz_typename P_expr2::T_numtype > > > | | Add<double, typename P_expr2::T_numtype > > > | |
| operator+(double d1, | | operator+(double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<double, _bz_typename P_expr2::T_numtype> > | | Add<double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double + IndexPlaceholder<N_index2> | | // double + IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<double, int > > > | | Add<double, int > > > | |
| operator+(double d1, | | operator+(double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<double, int> > | | Add<double, int> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double + Array<T_numtype2, N_rank2> | | // long double + Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<long double, T_numtype2 > > > | | Add<long double, T_numtype2 > > > | |
| operator+(long double d1, | | operator+(long double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<long double, T_numtype2> > | | Add<long double, T_numtype2> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // long double + _bz_ArrayExpr<P_expr2> | | // long double + _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<long double, _bz_typename P_expr2::T_numtype > > > | | Add<long double, typename P_expr2::T_numtype > > > | |
| operator+(long double d1, | | operator+(long double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<long double, _bz_typename P_expr2::T_numtype> > | | Add<long double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double + IndexPlaceholder<N_index2> | | // long double + IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<long double, int > > > | | Add<long double, int > > > | |
| operator+(long double d1, | | operator+(long double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<long double, int> > | | Add<long double, int> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> + Array<T_numtype2, N_rank2> | | // complex<T1> + Array<T_numtype2, N_rank2> | |
| template<class T1, class T_numtype2, int N_rank2> | | template<class T1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<complex<T1> , T_numtype2 > > > | | Add<complex<T1> , T_numtype2 > > > | |
| operator+(complex<T1> d1, | | operator+(complex<T1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Add<complex<T1> , T_numtype2> > | | Add<complex<T1> , T_numtype2> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> + _bz_ArrayExpr<P_expr2> | | // complex<T1> + _bz_ArrayExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | Add<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator+(complex<T1> d1, | | operator+(complex<T1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Add<complex<T1> , _bz_typename P_expr2::T_numtype> > | | Add<complex<T1> , typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> + IndexPlaceholder<N_index2> | | // complex<T1> + IndexPlaceholder<N_index2> | |
| template<class T1, int N_index2> | | template<class T1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<complex<T1> , int > > > | | Add<complex<T1> , int > > > | |
| operator+(complex<T1> d1, | | operator+(complex<T1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Add<complex<T1> , int> > | | Add<complex<T1> , int> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Subtraction Operators | | * Subtraction Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> - Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> - Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<T_numtype1, T_numtype2 > > > | | Subtract<T_numtype1, T_numtype2 > > > | |
| operator-(const Array<T_numtype1, N_rank1>& d1, | | operator-(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<T_numtype1, T_numtype2> > | | Subtract<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> - _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> - _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | Subtract<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator-(const Array<T_numtype1, N_rank1>& d1, | | operator-(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<T_numtype1, _bz_typename P_expr2::T_numtype> > | | Subtract<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> - IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> - IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<T_numtype1, int > > > | | Subtract<T_numtype1, int > > > | |
| operator-(const Array<T_numtype1, N_rank1>& d1, | | operator-(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<T_numtype1, int> > | | Subtract<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> - int | | // Array<T_numtype1, N_rank1> - int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Subtract<T_numtype1, int > > > | | Subtract<T_numtype1, int > > > | |
| operator-(const Array<T_numtype1, N_rank1>& d1, | | operator-(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Subtract<T_numtype1, int> > | | Subtract<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> - float | | // Array<T_numtype1, N_rank1> - float | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Subtract<T_numtype1, float > > > | | Subtract<T_numtype1, float > > > | |
| operator-(const Array<T_numtype1, N_rank1>& d1, | | operator-(const Array<T_numtype1, N_rank1>& d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Subtract<T_numtype1, float> > | | Subtract<T_numtype1, float> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> - double | | // Array<T_numtype1, N_rank1> - double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Subtract<T_numtype1, double > > > | | Subtract<T_numtype1, double > > > | |
| operator-(const Array<T_numtype1, N_rank1>& d1, | | operator-(const Array<T_numtype1, N_rank1>& d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Subtract<T_numtype1, double> > | | Subtract<T_numtype1, double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> - long double | | // Array<T_numtype1, N_rank1> - long double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Subtract<T_numtype1, long double > > > | | Subtract<T_numtype1, long double > > > | |
| operator-(const Array<T_numtype1, N_rank1>& d1, | | operator-(const Array<T_numtype1, N_rank1>& d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Subtract<T_numtype1, long double> > | | Subtract<T_numtype1, long double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // Array<T_numtype1, N_rank1> - complex<T2> | | // Array<T_numtype1, N_rank1> - complex<T2> | |
| template<class T_numtype1, int N_rank1, class T2> | | template<class T_numtype1, int N_rank1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Subtract<T_numtype1, complex<T2> > > > | | Subtract<T_numtype1, complex<T2> > > > | |
| operator-(const Array<T_numtype1, N_rank1>& d1, | | operator-(const Array<T_numtype1, N_rank1>& d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Subtract<T_numtype1, complex<T2> > > | | Subtract<T_numtype1, complex<T2> > > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_ArrayExpr<P_expr1> - Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> - Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | Subtract<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator-(_bz_ArrayExpr<P_expr1> d1, | | operator-(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, T_numtype2> > | | Subtract<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> - _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> - _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_num
type > > > | | Subtract<typename P_expr1::T_numtype, typename P_expr2::T_numtype > >
> | |
| operator-(_bz_ArrayExpr<P_expr1> d1, | | operator-(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_num
type> > | | Subtract<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> - IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> - IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, int > > > | | Subtract<typename P_expr1::T_numtype, int > > > | |
| operator-(_bz_ArrayExpr<P_expr1> d1, | | operator-(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, int> > | | Subtract<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> - int | | // _bz_ArrayExpr<P_expr1> - int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, int > > > | | Subtract<typename P_expr1::T_numtype, int > > > | |
| operator-(_bz_ArrayExpr<P_expr1> d1, | | operator-(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, int> > | | Subtract<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> - float | | // _bz_ArrayExpr<P_expr1> - float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, float > > > | | Subtract<typename P_expr1::T_numtype, float > > > | |
| operator-(_bz_ArrayExpr<P_expr1> d1, | | operator-(_bz_ArrayExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, float> > | | Subtract<typename P_expr1::T_numtype, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> - double | | // _bz_ArrayExpr<P_expr1> - double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, double > > > | | Subtract<typename P_expr1::T_numtype, double > > > | |
| operator-(_bz_ArrayExpr<P_expr1> d1, | | operator-(_bz_ArrayExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, double> > | | Subtract<typename P_expr1::T_numtype, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> - long double | | // _bz_ArrayExpr<P_expr1> - long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, long double > > > | | Subtract<typename P_expr1::T_numtype, long double > > > | |
| operator-(_bz_ArrayExpr<P_expr1> d1, | | operator-(_bz_ArrayExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Subtract<_bz_typename P_expr1::T_numtype, long double> > | | Subtract<typename P_expr1::T_numtype, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // _bz_ArrayExpr<P_expr1> - complex<T2> | | // _bz_ArrayExpr<P_expr1> - complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Subtract<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | Subtract<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator-(_bz_ArrayExpr<P_expr1> d1, | | operator-(_bz_ArrayExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Subtract<_bz_typename P_expr1::T_numtype, complex<T2> > > | | Subtract<typename P_expr1::T_numtype, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // IndexPlaceholder<N_index1> - Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> - Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<int, T_numtype2 > > > | | Subtract<int, T_numtype2 > > > | |
| operator-(IndexPlaceholder<N_index1> d1, | | operator-(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<int, T_numtype2> > | | Subtract<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> - _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> - _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<int, _bz_typename P_expr2::T_numtype > > > | | Subtract<int, typename P_expr2::T_numtype > > > | |
| operator-(IndexPlaceholder<N_index1> d1, | | operator-(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<int, _bz_typename P_expr2::T_numtype> > | | Subtract<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> - IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> - IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<int, int > > > | | Subtract<int, int > > > | |
| operator-(IndexPlaceholder<N_index1> d1, | | operator-(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<int, int> > | | Subtract<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> - int | | // IndexPlaceholder<N_index1> - int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Subtract<int, int > > > | | Subtract<int, int > > > | |
| operator-(IndexPlaceholder<N_index1> d1, | | operator-(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Subtract<int, int> > | | Subtract<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> - float | | // IndexPlaceholder<N_index1> - float | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Subtract<int, float > > > | | Subtract<int, float > > > | |
| operator-(IndexPlaceholder<N_index1> d1, | | operator-(IndexPlaceholder<N_index1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Subtract<int, float> > | | Subtract<int, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> - double | | // IndexPlaceholder<N_index1> - double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Subtract<int, double > > > | | Subtract<int, double > > > | |
| operator-(IndexPlaceholder<N_index1> d1, | | operator-(IndexPlaceholder<N_index1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Subtract<int, double> > | | Subtract<int, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> - long double | | // IndexPlaceholder<N_index1> - long double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Subtract<int, long double > > > | | Subtract<int, long double > > > | |
| operator-(IndexPlaceholder<N_index1> d1, | | operator-(IndexPlaceholder<N_index1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Subtract<int, long double> > | | Subtract<int, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // IndexPlaceholder<N_index1> - complex<T2> | | // IndexPlaceholder<N_index1> - complex<T2> | |
| template<int N_index1, class T2> | | template<int N_index1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Subtract<int, complex<T2> > > > | | Subtract<int, complex<T2> > > > | |
| operator-(IndexPlaceholder<N_index1> d1, | | operator-(IndexPlaceholder<N_index1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Subtract<int, complex<T2> > > | | Subtract<int, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int - Array<T_numtype2, N_rank2> | | // int - Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<int, T_numtype2 > > > | | Subtract<int, T_numtype2 > > > | |
| operator-(int d1, | | operator-(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<int, T_numtype2> > | | Subtract<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int - _bz_ArrayExpr<P_expr2> | | // int - _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<int, _bz_typename P_expr2::T_numtype > > > | | Subtract<int, typename P_expr2::T_numtype > > > | |
| operator-(int d1, | | operator-(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<int, _bz_typename P_expr2::T_numtype> > | | Subtract<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int - IndexPlaceholder<N_index2> | | // int - IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<int, int > > > | | Subtract<int, int > > > | |
| operator-(int d1, | | operator-(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<int, int> > | | Subtract<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float - Array<T_numtype2, N_rank2> | | // float - Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<float, T_numtype2 > > > | | Subtract<float, T_numtype2 > > > | |
| operator-(float d1, | | operator-(float d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<float, T_numtype2> > | | Subtract<float, T_numtype2> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // float - _bz_ArrayExpr<P_expr2> | | // float - _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<float, _bz_typename P_expr2::T_numtype > > > | | Subtract<float, typename P_expr2::T_numtype > > > | |
| operator-(float d1, | | operator-(float d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<float, _bz_typename P_expr2::T_numtype> > | | Subtract<float, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float - IndexPlaceholder<N_index2> | | // float - IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<float, int > > > | | Subtract<float, int > > > | |
| operator-(float d1, | | operator-(float d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<float, int> > | | Subtract<float, int> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double - Array<T_numtype2, N_rank2> | | // double - Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<double, T_numtype2 > > > | | Subtract<double, T_numtype2 > > > | |
| operator-(double d1, | | operator-(double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<double, T_numtype2> > | | Subtract<double, T_numtype2> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // double - _bz_ArrayExpr<P_expr2> | | // double - _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<double, _bz_typename P_expr2::T_numtype > > > | | Subtract<double, typename P_expr2::T_numtype > > > | |
| operator-(double d1, | | operator-(double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<double, _bz_typename P_expr2::T_numtype> > | | Subtract<double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double - IndexPlaceholder<N_index2> | | // double - IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<double, int > > > | | Subtract<double, int > > > | |
| operator-(double d1, | | operator-(double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<double, int> > | | Subtract<double, int> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double - Array<T_numtype2, N_rank2> | | // long double - Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<long double, T_numtype2 > > > | | Subtract<long double, T_numtype2 > > > | |
| operator-(long double d1, | | operator-(long double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<long double, T_numtype2> > | | Subtract<long double, T_numtype2> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // long double - _bz_ArrayExpr<P_expr2> | | // long double - _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<long double, _bz_typename P_expr2::T_numtype > > > | | Subtract<long double, typename P_expr2::T_numtype > > > | |
| operator-(long double d1, | | operator-(long double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<long double, _bz_typename P_expr2::T_numtype> > | | Subtract<long double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double - IndexPlaceholder<N_index2> | | // long double - IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<long double, int > > > | | Subtract<long double, int > > > | |
| operator-(long double d1, | | operator-(long double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<long double, int> > | | Subtract<long double, int> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> - Array<T_numtype2, N_rank2> | | // complex<T1> - Array<T_numtype2, N_rank2> | |
| template<class T1, class T_numtype2, int N_rank2> | | template<class T1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<complex<T1> , T_numtype2 > > > | | Subtract<complex<T1> , T_numtype2 > > > | |
| operator-(complex<T1> d1, | | operator-(complex<T1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Subtract<complex<T1> , T_numtype2> > | | Subtract<complex<T1> , T_numtype2> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> - _bz_ArrayExpr<P_expr2> | | // complex<T1> - _bz_ArrayExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | Subtract<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator-(complex<T1> d1, | | operator-(complex<T1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Subtract<complex<T1> , _bz_typename P_expr2::T_numtype> > | | Subtract<complex<T1> , typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> - IndexPlaceholder<N_index2> | | // complex<T1> - IndexPlaceholder<N_index2> | |
| template<class T1, int N_index2> | | template<class T1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<complex<T1> , int > > > | | Subtract<complex<T1> , int > > > | |
| operator-(complex<T1> d1, | | operator-(complex<T1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Subtract<complex<T1> , int> > | | Subtract<complex<T1> , int> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Multiplication Operators | | * Multiplication Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> * Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> * Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<T_numtype1, T_numtype2 > > > | | Multiply<T_numtype1, T_numtype2 > > > | |
| operator*(const Array<T_numtype1, N_rank1>& d1, | | operator*(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<T_numtype1, T_numtype2> > | | Multiply<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> * _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> * _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | Multiply<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator*(const Array<T_numtype1, N_rank1>& d1, | | operator*(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<T_numtype1, _bz_typename P_expr2::T_numtype> > | | Multiply<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> * IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> * IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<T_numtype1, int > > > | | Multiply<T_numtype1, int > > > | |
| operator*(const Array<T_numtype1, N_rank1>& d1, | | operator*(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<T_numtype1, int> > | | Multiply<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> * int | | // Array<T_numtype1, N_rank1> * int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Multiply<T_numtype1, int > > > | | Multiply<T_numtype1, int > > > | |
| operator*(const Array<T_numtype1, N_rank1>& d1, | | operator*(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Multiply<T_numtype1, int> > | | Multiply<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> * float | | // Array<T_numtype1, N_rank1> * float | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Multiply<T_numtype1, float > > > | | Multiply<T_numtype1, float > > > | |
| operator*(const Array<T_numtype1, N_rank1>& d1, | | operator*(const Array<T_numtype1, N_rank1>& d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Multiply<T_numtype1, float> > | | Multiply<T_numtype1, float> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> * double | | // Array<T_numtype1, N_rank1> * double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Multiply<T_numtype1, double > > > | | Multiply<T_numtype1, double > > > | |
| operator*(const Array<T_numtype1, N_rank1>& d1, | | operator*(const Array<T_numtype1, N_rank1>& d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Multiply<T_numtype1, double> > | | Multiply<T_numtype1, double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> * long double | | // Array<T_numtype1, N_rank1> * long double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Multiply<T_numtype1, long double > > > | | Multiply<T_numtype1, long double > > > | |
| operator*(const Array<T_numtype1, N_rank1>& d1, | | operator*(const Array<T_numtype1, N_rank1>& d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Multiply<T_numtype1, long double> > | | Multiply<T_numtype1, long double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // Array<T_numtype1, N_rank1> * complex<T2> | | // Array<T_numtype1, N_rank1> * complex<T2> | |
| template<class T_numtype1, int N_rank1, class T2> | | template<class T_numtype1, int N_rank1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Multiply<T_numtype1, complex<T2> > > > | | Multiply<T_numtype1, complex<T2> > > > | |
| operator*(const Array<T_numtype1, N_rank1>& d1, | | operator*(const Array<T_numtype1, N_rank1>& d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Multiply<T_numtype1, complex<T2> > > | | Multiply<T_numtype1, complex<T2> > > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_ArrayExpr<P_expr1> * Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> * Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | Multiply<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator*(_bz_ArrayExpr<P_expr1> d1, | | operator*(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, T_numtype2> > | | Multiply<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> * _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> * _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_num
type > > > | | Multiply<typename P_expr1::T_numtype, typename P_expr2::T_numtype > >
> | |
| operator*(_bz_ArrayExpr<P_expr1> d1, | | operator*(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_num
type> > | | Multiply<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> * IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> * IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, int > > > | | Multiply<typename P_expr1::T_numtype, int > > > | |
| operator*(_bz_ArrayExpr<P_expr1> d1, | | operator*(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, int> > | | Multiply<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> * int | | // _bz_ArrayExpr<P_expr1> * int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, int > > > | | Multiply<typename P_expr1::T_numtype, int > > > | |
| operator*(_bz_ArrayExpr<P_expr1> d1, | | operator*(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, int> > | | Multiply<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> * float | | // _bz_ArrayExpr<P_expr1> * float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, float > > > | | Multiply<typename P_expr1::T_numtype, float > > > | |
| operator*(_bz_ArrayExpr<P_expr1> d1, | | operator*(_bz_ArrayExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, float> > | | Multiply<typename P_expr1::T_numtype, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> * double | | // _bz_ArrayExpr<P_expr1> * double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, double > > > | | Multiply<typename P_expr1::T_numtype, double > > > | |
| operator*(_bz_ArrayExpr<P_expr1> d1, | | operator*(_bz_ArrayExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, double> > | | Multiply<typename P_expr1::T_numtype, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> * long double | | // _bz_ArrayExpr<P_expr1> * long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, long double > > > | | Multiply<typename P_expr1::T_numtype, long double > > > | |
| operator*(_bz_ArrayExpr<P_expr1> d1, | | operator*(_bz_ArrayExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Multiply<_bz_typename P_expr1::T_numtype, long double> > | | Multiply<typename P_expr1::T_numtype, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // _bz_ArrayExpr<P_expr1> * complex<T2> | | // _bz_ArrayExpr<P_expr1> * complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Multiply<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | Multiply<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator*(_bz_ArrayExpr<P_expr1> d1, | | operator*(_bz_ArrayExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Multiply<_bz_typename P_expr1::T_numtype, complex<T2> > > | | Multiply<typename P_expr1::T_numtype, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // IndexPlaceholder<N_index1> * Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> * Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<int, T_numtype2 > > > | | Multiply<int, T_numtype2 > > > | |
| operator*(IndexPlaceholder<N_index1> d1, | | operator*(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<int, T_numtype2> > | | Multiply<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> * _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> * _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<int, _bz_typename P_expr2::T_numtype > > > | | Multiply<int, typename P_expr2::T_numtype > > > | |
| operator*(IndexPlaceholder<N_index1> d1, | | operator*(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<int, _bz_typename P_expr2::T_numtype> > | | Multiply<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> * IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> * IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<int, int > > > | | Multiply<int, int > > > | |
| operator*(IndexPlaceholder<N_index1> d1, | | operator*(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<int, int> > | | Multiply<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> * int | | // IndexPlaceholder<N_index1> * int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Multiply<int, int > > > | | Multiply<int, int > > > | |
| operator*(IndexPlaceholder<N_index1> d1, | | operator*(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Multiply<int, int> > | | Multiply<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> * float | | // IndexPlaceholder<N_index1> * float | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Multiply<int, float > > > | | Multiply<int, float > > > | |
| operator*(IndexPlaceholder<N_index1> d1, | | operator*(IndexPlaceholder<N_index1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Multiply<int, float> > | | Multiply<int, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> * double | | // IndexPlaceholder<N_index1> * double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Multiply<int, double > > > | | Multiply<int, double > > > | |
| operator*(IndexPlaceholder<N_index1> d1, | | operator*(IndexPlaceholder<N_index1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Multiply<int, double> > | | Multiply<int, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> * long double | | // IndexPlaceholder<N_index1> * long double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Multiply<int, long double > > > | | Multiply<int, long double > > > | |
| operator*(IndexPlaceholder<N_index1> d1, | | operator*(IndexPlaceholder<N_index1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Multiply<int, long double> > | | Multiply<int, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // IndexPlaceholder<N_index1> * complex<T2> | | // IndexPlaceholder<N_index1> * complex<T2> | |
| template<int N_index1, class T2> | | template<int N_index1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Multiply<int, complex<T2> > > > | | Multiply<int, complex<T2> > > > | |
| operator*(IndexPlaceholder<N_index1> d1, | | operator*(IndexPlaceholder<N_index1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Multiply<int, complex<T2> > > | | Multiply<int, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int * Array<T_numtype2, N_rank2> | | // int * Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<int, T_numtype2 > > > | | Multiply<int, T_numtype2 > > > | |
| operator*(int d1, | | operator*(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<int, T_numtype2> > | | Multiply<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int * _bz_ArrayExpr<P_expr2> | | // int * _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<int, _bz_typename P_expr2::T_numtype > > > | | Multiply<int, typename P_expr2::T_numtype > > > | |
| operator*(int d1, | | operator*(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<int, _bz_typename P_expr2::T_numtype> > | | Multiply<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int * IndexPlaceholder<N_index2> | | // int * IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<int, int > > > | | Multiply<int, int > > > | |
| operator*(int d1, | | operator*(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<int, int> > | | Multiply<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float * Array<T_numtype2, N_rank2> | | // float * Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<float, T_numtype2 > > > | | Multiply<float, T_numtype2 > > > | |
| operator*(float d1, | | operator*(float d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<float, T_numtype2> > | | Multiply<float, T_numtype2> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // float * _bz_ArrayExpr<P_expr2> | | // float * _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<float, _bz_typename P_expr2::T_numtype > > > | | Multiply<float, typename P_expr2::T_numtype > > > | |
| operator*(float d1, | | operator*(float d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<float, _bz_typename P_expr2::T_numtype> > | | Multiply<float, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float * IndexPlaceholder<N_index2> | | // float * IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<float, int > > > | | Multiply<float, int > > > | |
| operator*(float d1, | | operator*(float d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<float, int> > | | Multiply<float, int> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double * Array<T_numtype2, N_rank2> | | // double * Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<double, T_numtype2 > > > | | Multiply<double, T_numtype2 > > > | |
| operator*(double d1, | | operator*(double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<double, T_numtype2> > | | Multiply<double, T_numtype2> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // double * _bz_ArrayExpr<P_expr2> | | // double * _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<double, _bz_typename P_expr2::T_numtype > > > | | Multiply<double, typename P_expr2::T_numtype > > > | |
| operator*(double d1, | | operator*(double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<double, _bz_typename P_expr2::T_numtype> > | | Multiply<double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double * IndexPlaceholder<N_index2> | | // double * IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<double, int > > > | | Multiply<double, int > > > | |
| operator*(double d1, | | operator*(double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<double, int> > | | Multiply<double, int> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double * Array<T_numtype2, N_rank2> | | // long double * Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<long double, T_numtype2 > > > | | Multiply<long double, T_numtype2 > > > | |
| operator*(long double d1, | | operator*(long double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<long double, T_numtype2> > | | Multiply<long double, T_numtype2> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // long double * _bz_ArrayExpr<P_expr2> | | // long double * _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<long double, _bz_typename P_expr2::T_numtype > > > | | Multiply<long double, typename P_expr2::T_numtype > > > | |
| operator*(long double d1, | | operator*(long double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<long double, _bz_typename P_expr2::T_numtype> > | | Multiply<long double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double * IndexPlaceholder<N_index2> | | // long double * IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<long double, int > > > | | Multiply<long double, int > > > | |
| operator*(long double d1, | | operator*(long double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<long double, int> > | | Multiply<long double, int> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> * Array<T_numtype2, N_rank2> | | // complex<T1> * Array<T_numtype2, N_rank2> | |
| template<class T1, class T_numtype2, int N_rank2> | | template<class T1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<complex<T1> , T_numtype2 > > > | | Multiply<complex<T1> , T_numtype2 > > > | |
| operator*(complex<T1> d1, | | operator*(complex<T1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Multiply<complex<T1> , T_numtype2> > | | Multiply<complex<T1> , T_numtype2> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> * _bz_ArrayExpr<P_expr2> | | // complex<T1> * _bz_ArrayExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | Multiply<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator*(complex<T1> d1, | | operator*(complex<T1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Multiply<complex<T1> , _bz_typename P_expr2::T_numtype> > | | Multiply<complex<T1> , typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> * IndexPlaceholder<N_index2> | | // complex<T1> * IndexPlaceholder<N_index2> | |
| template<class T1, int N_index2> | | template<class T1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<complex<T1> , int > > > | | Multiply<complex<T1> , int > > > | |
| operator*(complex<T1> d1, | | operator*(complex<T1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Multiply<complex<T1> , int> > | | Multiply<complex<T1> , int> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Division Operators | | * Division Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> / Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> / Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<T_numtype1, T_numtype2 > > > | | Divide<T_numtype1, T_numtype2 > > > | |
| operator/(const Array<T_numtype1, N_rank1>& d1, | | operator/(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<T_numtype1, T_numtype2> > | | Divide<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> / _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> / _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | Divide<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator/(const Array<T_numtype1, N_rank1>& d1, | | operator/(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<T_numtype1, _bz_typename P_expr2::T_numtype> > | | Divide<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> / IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> / IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<T_numtype1, int > > > | | Divide<T_numtype1, int > > > | |
| operator/(const Array<T_numtype1, N_rank1>& d1, | | operator/(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<T_numtype1, int> > | | Divide<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> / int | | // Array<T_numtype1, N_rank1> / int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Divide<T_numtype1, int > > > | | Divide<T_numtype1, int > > > | |
| operator/(const Array<T_numtype1, N_rank1>& d1, | | operator/(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Divide<T_numtype1, int> > | | Divide<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> / float | | // Array<T_numtype1, N_rank1> / float | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Divide<T_numtype1, float > > > | | Divide<T_numtype1, float > > > | |
| operator/(const Array<T_numtype1, N_rank1>& d1, | | operator/(const Array<T_numtype1, N_rank1>& d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Divide<T_numtype1, float> > | | Divide<T_numtype1, float> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> / double | | // Array<T_numtype1, N_rank1> / double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Divide<T_numtype1, double > > > | | Divide<T_numtype1, double > > > | |
| operator/(const Array<T_numtype1, N_rank1>& d1, | | operator/(const Array<T_numtype1, N_rank1>& d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Divide<T_numtype1, double> > | | Divide<T_numtype1, double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> / long double | | // Array<T_numtype1, N_rank1> / long double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Divide<T_numtype1, long double > > > | | Divide<T_numtype1, long double > > > | |
| operator/(const Array<T_numtype1, N_rank1>& d1, | | operator/(const Array<T_numtype1, N_rank1>& d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Divide<T_numtype1, long double> > | | Divide<T_numtype1, long double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // Array<T_numtype1, N_rank1> / complex<T2> | | // Array<T_numtype1, N_rank1> / complex<T2> | |
| template<class T_numtype1, int N_rank1, class T2> | | template<class T_numtype1, int N_rank1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Divide<T_numtype1, complex<T2> > > > | | Divide<T_numtype1, complex<T2> > > > | |
| operator/(const Array<T_numtype1, N_rank1>& d1, | | operator/(const Array<T_numtype1, N_rank1>& d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Divide<T_numtype1, complex<T2> > > | | Divide<T_numtype1, complex<T2> > > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_ArrayExpr<P_expr1> / Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> / Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | Divide<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator/(_bz_ArrayExpr<P_expr1> d1, | | operator/(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, T_numtype2> > | | Divide<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> / _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> / _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numty
pe > > > | | Divide<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > > | |
| operator/(_bz_ArrayExpr<P_expr1> d1, | | operator/(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numty
pe> > | | Divide<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> / IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> / IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, int > > > | | Divide<typename P_expr1::T_numtype, int > > > | |
| operator/(_bz_ArrayExpr<P_expr1> d1, | | operator/(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, int> > | | Divide<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> / int | | // _bz_ArrayExpr<P_expr1> / int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, int > > > | | Divide<typename P_expr1::T_numtype, int > > > | |
| operator/(_bz_ArrayExpr<P_expr1> d1, | | operator/(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, int> > | | Divide<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> / float | | // _bz_ArrayExpr<P_expr1> / float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, float > > > | | Divide<typename P_expr1::T_numtype, float > > > | |
| operator/(_bz_ArrayExpr<P_expr1> d1, | | operator/(_bz_ArrayExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, float> > | | Divide<typename P_expr1::T_numtype, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> / double | | // _bz_ArrayExpr<P_expr1> / double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, double > > > | | Divide<typename P_expr1::T_numtype, double > > > | |
| operator/(_bz_ArrayExpr<P_expr1> d1, | | operator/(_bz_ArrayExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, double> > | | Divide<typename P_expr1::T_numtype, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> / long double | | // _bz_ArrayExpr<P_expr1> / long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, long double > > > | | Divide<typename P_expr1::T_numtype, long double > > > | |
| operator/(_bz_ArrayExpr<P_expr1> d1, | | operator/(_bz_ArrayExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Divide<_bz_typename P_expr1::T_numtype, long double> > | | Divide<typename P_expr1::T_numtype, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // _bz_ArrayExpr<P_expr1> / complex<T2> | | // _bz_ArrayExpr<P_expr1> / complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Divide<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | Divide<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator/(_bz_ArrayExpr<P_expr1> d1, | | operator/(_bz_ArrayExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Divide<_bz_typename P_expr1::T_numtype, complex<T2> > > | | Divide<typename P_expr1::T_numtype, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // IndexPlaceholder<N_index1> / Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> / Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<int, T_numtype2 > > > | | Divide<int, T_numtype2 > > > | |
| operator/(IndexPlaceholder<N_index1> d1, | | operator/(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<int, T_numtype2> > | | Divide<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> / _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> / _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<int, _bz_typename P_expr2::T_numtype > > > | | Divide<int, typename P_expr2::T_numtype > > > | |
| operator/(IndexPlaceholder<N_index1> d1, | | operator/(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<int, _bz_typename P_expr2::T_numtype> > | | Divide<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> / IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> / IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<int, int > > > | | Divide<int, int > > > | |
| operator/(IndexPlaceholder<N_index1> d1, | | operator/(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<int, int> > | | Divide<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> / int | | // IndexPlaceholder<N_index1> / int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Divide<int, int > > > | | Divide<int, int > > > | |
| operator/(IndexPlaceholder<N_index1> d1, | | operator/(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Divide<int, int> > | | Divide<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> / float | | // IndexPlaceholder<N_index1> / float | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Divide<int, float > > > | | Divide<int, float > > > | |
| operator/(IndexPlaceholder<N_index1> d1, | | operator/(IndexPlaceholder<N_index1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Divide<int, float> > | | Divide<int, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> / double | | // IndexPlaceholder<N_index1> / double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Divide<int, double > > > | | Divide<int, double > > > | |
| operator/(IndexPlaceholder<N_index1> d1, | | operator/(IndexPlaceholder<N_index1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Divide<int, double> > | | Divide<int, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> / long double | | // IndexPlaceholder<N_index1> / long double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Divide<int, long double > > > | | Divide<int, long double > > > | |
| operator/(IndexPlaceholder<N_index1> d1, | | operator/(IndexPlaceholder<N_index1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Divide<int, long double> > | | Divide<int, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // IndexPlaceholder<N_index1> / complex<T2> | | // IndexPlaceholder<N_index1> / complex<T2> | |
| template<int N_index1, class T2> | | template<int N_index1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Divide<int, complex<T2> > > > | | Divide<int, complex<T2> > > > | |
| operator/(IndexPlaceholder<N_index1> d1, | | operator/(IndexPlaceholder<N_index1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Divide<int, complex<T2> > > | | Divide<int, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int / Array<T_numtype2, N_rank2> | | // int / Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<int, T_numtype2 > > > | | Divide<int, T_numtype2 > > > | |
| operator/(int d1, | | operator/(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<int, T_numtype2> > | | Divide<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int / _bz_ArrayExpr<P_expr2> | | // int / _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<int, _bz_typename P_expr2::T_numtype > > > | | Divide<int, typename P_expr2::T_numtype > > > | |
| operator/(int d1, | | operator/(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<int, _bz_typename P_expr2::T_numtype> > | | Divide<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int / IndexPlaceholder<N_index2> | | // int / IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<int, int > > > | | Divide<int, int > > > | |
| operator/(int d1, | | operator/(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<int, int> > | | Divide<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float / Array<T_numtype2, N_rank2> | | // float / Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<float, T_numtype2 > > > | | Divide<float, T_numtype2 > > > | |
| operator/(float d1, | | operator/(float d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<float, T_numtype2> > | | Divide<float, T_numtype2> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // float / _bz_ArrayExpr<P_expr2> | | // float / _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<float, _bz_typename P_expr2::T_numtype > > > | | Divide<float, typename P_expr2::T_numtype > > > | |
| operator/(float d1, | | operator/(float d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<float, _bz_typename P_expr2::T_numtype> > | | Divide<float, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float / IndexPlaceholder<N_index2> | | // float / IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<float, int > > > | | Divide<float, int > > > | |
| operator/(float d1, | | operator/(float d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<float, int> > | | Divide<float, int> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double / Array<T_numtype2, N_rank2> | | // double / Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<double, T_numtype2 > > > | | Divide<double, T_numtype2 > > > | |
| operator/(double d1, | | operator/(double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<double, T_numtype2> > | | Divide<double, T_numtype2> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // double / _bz_ArrayExpr<P_expr2> | | // double / _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<double, _bz_typename P_expr2::T_numtype > > > | | Divide<double, typename P_expr2::T_numtype > > > | |
| operator/(double d1, | | operator/(double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<double, _bz_typename P_expr2::T_numtype> > | | Divide<double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double / IndexPlaceholder<N_index2> | | // double / IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<double, int > > > | | Divide<double, int > > > | |
| operator/(double d1, | | operator/(double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<double, int> > | | Divide<double, int> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double / Array<T_numtype2, N_rank2> | | // long double / Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<long double, T_numtype2 > > > | | Divide<long double, T_numtype2 > > > | |
| operator/(long double d1, | | operator/(long double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<long double, T_numtype2> > | | Divide<long double, T_numtype2> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // long double / _bz_ArrayExpr<P_expr2> | | // long double / _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<long double, _bz_typename P_expr2::T_numtype > > > | | Divide<long double, typename P_expr2::T_numtype > > > | |
| operator/(long double d1, | | operator/(long double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<long double, _bz_typename P_expr2::T_numtype> > | | Divide<long double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double / IndexPlaceholder<N_index2> | | // long double / IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<long double, int > > > | | Divide<long double, int > > > | |
| operator/(long double d1, | | operator/(long double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<long double, int> > | | Divide<long double, int> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> / Array<T_numtype2, N_rank2> | | // complex<T1> / Array<T_numtype2, N_rank2> | |
| template<class T1, class T_numtype2, int N_rank2> | | template<class T1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<complex<T1> , T_numtype2 > > > | | Divide<complex<T1> , T_numtype2 > > > | |
| operator/(complex<T1> d1, | | operator/(complex<T1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Divide<complex<T1> , T_numtype2> > | | Divide<complex<T1> , T_numtype2> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> / _bz_ArrayExpr<P_expr2> | | // complex<T1> / _bz_ArrayExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | Divide<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator/(complex<T1> d1, | | operator/(complex<T1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Divide<complex<T1> , _bz_typename P_expr2::T_numtype> > | | Divide<complex<T1> , typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> / IndexPlaceholder<N_index2> | | // complex<T1> / IndexPlaceholder<N_index2> | |
| template<class T1, int N_index2> | | template<class T1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<complex<T1> , int > > > | | Divide<complex<T1> , int > > > | |
| operator/(complex<T1> d1, | | operator/(complex<T1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Divide<complex<T1> , int> > | | Divide<complex<T1> , int> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Modulus Operators | | * Modulus Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> % Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> % Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Modulo<T_numtype1, T_numtype2 > > > | | Modulo<T_numtype1, T_numtype2 > > > | |
| operator%(const Array<T_numtype1, N_rank1>& d1, | | operator%(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Modulo<T_numtype1, T_numtype2> > | | Modulo<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> % _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> % _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Modulo<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | Modulo<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator%(const Array<T_numtype1, N_rank1>& d1, | | operator%(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Modulo<T_numtype1, _bz_typename P_expr2::T_numtype> > | | Modulo<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> % IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> % IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Modulo<T_numtype1, int > > > | | Modulo<T_numtype1, int > > > | |
| operator%(const Array<T_numtype1, N_rank1>& d1, | | operator%(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Modulo<T_numtype1, int> > | | Modulo<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> % int | | // Array<T_numtype1, N_rank1> % int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Modulo<T_numtype1, int > > > | | Modulo<T_numtype1, int > > > | |
| operator%(const Array<T_numtype1, N_rank1>& d1, | | operator%(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Modulo<T_numtype1, int> > | | Modulo<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> % Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> % Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Modulo<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | Modulo<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator%(_bz_ArrayExpr<P_expr1> d1, | | operator%(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Modulo<_bz_typename P_expr1::T_numtype, T_numtype2> > | | Modulo<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> % _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> % _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Modulo<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numty
pe > > > | | Modulo<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > > | |
| operator%(_bz_ArrayExpr<P_expr1> d1, | | operator%(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Modulo<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numty
pe> > | | Modulo<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> % IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> % IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Modulo<_bz_typename P_expr1::T_numtype, int > > > | | Modulo<typename P_expr1::T_numtype, int > > > | |
| operator%(_bz_ArrayExpr<P_expr1> d1, | | operator%(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Modulo<_bz_typename P_expr1::T_numtype, int> > | | Modulo<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> % int | | // _bz_ArrayExpr<P_expr1> % int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Modulo<_bz_typename P_expr1::T_numtype, int > > > | | Modulo<typename P_expr1::T_numtype, int > > > | |
| operator%(_bz_ArrayExpr<P_expr1> d1, | | operator%(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Modulo<_bz_typename P_expr1::T_numtype, int> > | | Modulo<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> % Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> % Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Modulo<int, T_numtype2 > > > | | Modulo<int, T_numtype2 > > > | |
| operator%(IndexPlaceholder<N_index1> d1, | | operator%(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Modulo<int, T_numtype2> > | | Modulo<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> % _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> % _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Modulo<int, _bz_typename P_expr2::T_numtype > > > | | Modulo<int, typename P_expr2::T_numtype > > > | |
| operator%(IndexPlaceholder<N_index1> d1, | | operator%(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Modulo<int, _bz_typename P_expr2::T_numtype> > | | Modulo<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> % IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> % IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Modulo<int, int > > > | | Modulo<int, int > > > | |
| operator%(IndexPlaceholder<N_index1> d1, | | operator%(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Modulo<int, int> > | | Modulo<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> % int | | // IndexPlaceholder<N_index1> % int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Modulo<int, int > > > | | Modulo<int, int > > > | |
| operator%(IndexPlaceholder<N_index1> d1, | | operator%(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Modulo<int, int> > | | Modulo<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // int % Array<T_numtype2, N_rank2> | | // int % Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Modulo<int, T_numtype2 > > > | | Modulo<int, T_numtype2 > > > | |
| operator%(int d1, | | operator%(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Modulo<int, T_numtype2> > | | Modulo<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int % _bz_ArrayExpr<P_expr2> | | // int % _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Modulo<int, _bz_typename P_expr2::T_numtype > > > | | Modulo<int, typename P_expr2::T_numtype > > > | |
| operator%(int d1, | | operator%(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Modulo<int, _bz_typename P_expr2::T_numtype> > | | Modulo<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int % IndexPlaceholder<N_index2> | | // int % IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Modulo<int, int > > > | | Modulo<int, int > > > | |
| operator%(int d1, | | operator%(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Modulo<int, int> > | | Modulo<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Greater-than Operators | | * Greater-than Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> > Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> > Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<T_numtype1, T_numtype2 > > > | | Greater<T_numtype1, T_numtype2 > > > | |
| operator>(const Array<T_numtype1, N_rank1>& d1, | | operator>(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<T_numtype1, T_numtype2> > | | Greater<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> > _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> > _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | Greater<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator>(const Array<T_numtype1, N_rank1>& d1, | | operator>(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<T_numtype1, _bz_typename P_expr2::T_numtype> > | | Greater<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> > IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> > IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<T_numtype1, int > > > | | Greater<T_numtype1, int > > > | |
| operator>(const Array<T_numtype1, N_rank1>& d1, | | operator>(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<T_numtype1, int> > | | Greater<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> > int | | // Array<T_numtype1, N_rank1> > int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Greater<T_numtype1, int > > > | | Greater<T_numtype1, int > > > | |
| operator>(const Array<T_numtype1, N_rank1>& d1, | | operator>(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Greater<T_numtype1, int> > | | Greater<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> > float | | // Array<T_numtype1, N_rank1> > float | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Greater<T_numtype1, float > > > | | Greater<T_numtype1, float > > > | |
| operator>(const Array<T_numtype1, N_rank1>& d1, | | operator>(const Array<T_numtype1, N_rank1>& d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Greater<T_numtype1, float> > | | Greater<T_numtype1, float> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> > double | | // Array<T_numtype1, N_rank1> > double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Greater<T_numtype1, double > > > | | Greater<T_numtype1, double > > > | |
| operator>(const Array<T_numtype1, N_rank1>& d1, | | operator>(const Array<T_numtype1, N_rank1>& d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Greater<T_numtype1, double> > | | Greater<T_numtype1, double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> > long double | | // Array<T_numtype1, N_rank1> > long double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Greater<T_numtype1, long double > > > | | Greater<T_numtype1, long double > > > | |
| operator>(const Array<T_numtype1, N_rank1>& d1, | | operator>(const Array<T_numtype1, N_rank1>& d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Greater<T_numtype1, long double> > | | Greater<T_numtype1, long double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // Array<T_numtype1, N_rank1> > complex<T2> | | // Array<T_numtype1, N_rank1> > complex<T2> | |
| template<class T_numtype1, int N_rank1, class T2> | | template<class T_numtype1, int N_rank1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Greater<T_numtype1, complex<T2> > > > | | Greater<T_numtype1, complex<T2> > > > | |
| operator>(const Array<T_numtype1, N_rank1>& d1, | | operator>(const Array<T_numtype1, N_rank1>& d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Greater<T_numtype1, complex<T2> > > | | Greater<T_numtype1, complex<T2> > > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_ArrayExpr<P_expr1> > Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> > Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | Greater<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator>(_bz_ArrayExpr<P_expr1> d1, | | operator>(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, T_numtype2> > | | Greater<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> > _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> > _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numt
ype > > > | | Greater<typename P_expr1::T_numtype, typename P_expr2::T_numtype > >
> | |
| operator>(_bz_ArrayExpr<P_expr1> d1, | | operator>(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numt
ype> > | | Greater<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> > IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> > IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, int > > > | | Greater<typename P_expr1::T_numtype, int > > > | |
| operator>(_bz_ArrayExpr<P_expr1> d1, | | operator>(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, int> > | | Greater<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> > int | | // _bz_ArrayExpr<P_expr1> > int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, int > > > | | Greater<typename P_expr1::T_numtype, int > > > | |
| operator>(_bz_ArrayExpr<P_expr1> d1, | | operator>(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, int> > | | Greater<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> > float | | // _bz_ArrayExpr<P_expr1> > float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, float > > > | | Greater<typename P_expr1::T_numtype, float > > > | |
| operator>(_bz_ArrayExpr<P_expr1> d1, | | operator>(_bz_ArrayExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, float> > | | Greater<typename P_expr1::T_numtype, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> > double | | // _bz_ArrayExpr<P_expr1> > double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, double > > > | | Greater<typename P_expr1::T_numtype, double > > > | |
| operator>(_bz_ArrayExpr<P_expr1> d1, | | operator>(_bz_ArrayExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, double> > | | Greater<typename P_expr1::T_numtype, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> > long double | | // _bz_ArrayExpr<P_expr1> > long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, long double > > > | | Greater<typename P_expr1::T_numtype, long double > > > | |
| operator>(_bz_ArrayExpr<P_expr1> d1, | | operator>(_bz_ArrayExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Greater<_bz_typename P_expr1::T_numtype, long double> > | | Greater<typename P_expr1::T_numtype, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // _bz_ArrayExpr<P_expr1> > complex<T2> | | // _bz_ArrayExpr<P_expr1> > complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Greater<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | Greater<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator>(_bz_ArrayExpr<P_expr1> d1, | | operator>(_bz_ArrayExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Greater<_bz_typename P_expr1::T_numtype, complex<T2> > > | | Greater<typename P_expr1::T_numtype, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // IndexPlaceholder<N_index1> > Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> > Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<int, T_numtype2 > > > | | Greater<int, T_numtype2 > > > | |
| operator>(IndexPlaceholder<N_index1> d1, | | operator>(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<int, T_numtype2> > | | Greater<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> > _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> > _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<int, _bz_typename P_expr2::T_numtype > > > | | Greater<int, typename P_expr2::T_numtype > > > | |
| operator>(IndexPlaceholder<N_index1> d1, | | operator>(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<int, _bz_typename P_expr2::T_numtype> > | | Greater<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> > IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> > IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<int, int > > > | | Greater<int, int > > > | |
| operator>(IndexPlaceholder<N_index1> d1, | | operator>(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<int, int> > | | Greater<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> > int | | // IndexPlaceholder<N_index1> > int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Greater<int, int > > > | | Greater<int, int > > > | |
| operator>(IndexPlaceholder<N_index1> d1, | | operator>(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Greater<int, int> > | | Greater<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> > float | | // IndexPlaceholder<N_index1> > float | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Greater<int, float > > > | | Greater<int, float > > > | |
| operator>(IndexPlaceholder<N_index1> d1, | | operator>(IndexPlaceholder<N_index1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Greater<int, float> > | | Greater<int, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> > double | | // IndexPlaceholder<N_index1> > double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Greater<int, double > > > | | Greater<int, double > > > | |
| operator>(IndexPlaceholder<N_index1> d1, | | operator>(IndexPlaceholder<N_index1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Greater<int, double> > | | Greater<int, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> > long double | | // IndexPlaceholder<N_index1> > long double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Greater<int, long double > > > | | Greater<int, long double > > > | |
| operator>(IndexPlaceholder<N_index1> d1, | | operator>(IndexPlaceholder<N_index1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Greater<int, long double> > | | Greater<int, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // IndexPlaceholder<N_index1> > complex<T2> | | // IndexPlaceholder<N_index1> > complex<T2> | |
| template<int N_index1, class T2> | | template<int N_index1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Greater<int, complex<T2> > > > | | Greater<int, complex<T2> > > > | |
| operator>(IndexPlaceholder<N_index1> d1, | | operator>(IndexPlaceholder<N_index1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Greater<int, complex<T2> > > | | Greater<int, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int > Array<T_numtype2, N_rank2> | | // int > Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<int, T_numtype2 > > > | | Greater<int, T_numtype2 > > > | |
| operator>(int d1, | | operator>(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<int, T_numtype2> > | | Greater<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int > _bz_ArrayExpr<P_expr2> | | // int > _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<int, _bz_typename P_expr2::T_numtype > > > | | Greater<int, typename P_expr2::T_numtype > > > | |
| operator>(int d1, | | operator>(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<int, _bz_typename P_expr2::T_numtype> > | | Greater<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int > IndexPlaceholder<N_index2> | | // int > IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<int, int > > > | | Greater<int, int > > > | |
| operator>(int d1, | | operator>(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<int, int> > | | Greater<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float > Array<T_numtype2, N_rank2> | | // float > Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<float, T_numtype2 > > > | | Greater<float, T_numtype2 > > > | |
| operator>(float d1, | | operator>(float d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<float, T_numtype2> > | | Greater<float, T_numtype2> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // float > _bz_ArrayExpr<P_expr2> | | // float > _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<float, _bz_typename P_expr2::T_numtype > > > | | Greater<float, typename P_expr2::T_numtype > > > | |
| operator>(float d1, | | operator>(float d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<float, _bz_typename P_expr2::T_numtype> > | | Greater<float, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float > IndexPlaceholder<N_index2> | | // float > IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<float, int > > > | | Greater<float, int > > > | |
| operator>(float d1, | | operator>(float d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<float, int> > | | Greater<float, int> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double > Array<T_numtype2, N_rank2> | | // double > Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<double, T_numtype2 > > > | | Greater<double, T_numtype2 > > > | |
| operator>(double d1, | | operator>(double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<double, T_numtype2> > | | Greater<double, T_numtype2> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // double > _bz_ArrayExpr<P_expr2> | | // double > _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<double, _bz_typename P_expr2::T_numtype > > > | | Greater<double, typename P_expr2::T_numtype > > > | |
| operator>(double d1, | | operator>(double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<double, _bz_typename P_expr2::T_numtype> > | | Greater<double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double > IndexPlaceholder<N_index2> | | // double > IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<double, int > > > | | Greater<double, int > > > | |
| operator>(double d1, | | operator>(double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<double, int> > | | Greater<double, int> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double > Array<T_numtype2, N_rank2> | | // long double > Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<long double, T_numtype2 > > > | | Greater<long double, T_numtype2 > > > | |
| operator>(long double d1, | | operator>(long double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<long double, T_numtype2> > | | Greater<long double, T_numtype2> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // long double > _bz_ArrayExpr<P_expr2> | | // long double > _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<long double, _bz_typename P_expr2::T_numtype > > > | | Greater<long double, typename P_expr2::T_numtype > > > | |
| operator>(long double d1, | | operator>(long double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<long double, _bz_typename P_expr2::T_numtype> > | | Greater<long double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double > IndexPlaceholder<N_index2> | | // long double > IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<long double, int > > > | | Greater<long double, int > > > | |
| operator>(long double d1, | | operator>(long double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<long double, int> > | | Greater<long double, int> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> > Array<T_numtype2, N_rank2> | | // complex<T1> > Array<T_numtype2, N_rank2> | |
| template<class T1, class T_numtype2, int N_rank2> | | template<class T1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<complex<T1> , T_numtype2 > > > | | Greater<complex<T1> , T_numtype2 > > > | |
| operator>(complex<T1> d1, | | operator>(complex<T1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Greater<complex<T1> , T_numtype2> > | | Greater<complex<T1> , T_numtype2> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> > _bz_ArrayExpr<P_expr2> | | // complex<T1> > _bz_ArrayExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | Greater<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator>(complex<T1> d1, | | operator>(complex<T1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Greater<complex<T1> , _bz_typename P_expr2::T_numtype> > | | Greater<complex<T1> , typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> > IndexPlaceholder<N_index2> | | // complex<T1> > IndexPlaceholder<N_index2> | |
| template<class T1, int N_index2> | | template<class T1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<complex<T1> , int > > > | | Greater<complex<T1> , int > > > | |
| operator>(complex<T1> d1, | | operator>(complex<T1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Greater<complex<T1> , int> > | | Greater<complex<T1> , int> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Less-than Operators | | * Less-than Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> < Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> < Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<T_numtype1, T_numtype2 > > > | | Less<T_numtype1, T_numtype2 > > > | |
| operator<(const Array<T_numtype1, N_rank1>& d1, | | operator<(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<T_numtype1, T_numtype2> > | | Less<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> < _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> < _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | Less<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator<(const Array<T_numtype1, N_rank1>& d1, | | operator<(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<T_numtype1, _bz_typename P_expr2::T_numtype> > | | Less<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> < IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> < IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<T_numtype1, int > > > | | Less<T_numtype1, int > > > | |
| operator<(const Array<T_numtype1, N_rank1>& d1, | | operator<(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<T_numtype1, int> > | | Less<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> < int | | // Array<T_numtype1, N_rank1> < int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Less<T_numtype1, int > > > | | Less<T_numtype1, int > > > | |
| operator<(const Array<T_numtype1, N_rank1>& d1, | | operator<(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Less<T_numtype1, int> > | | Less<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> < float | | // Array<T_numtype1, N_rank1> < float | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Less<T_numtype1, float > > > | | Less<T_numtype1, float > > > | |
| operator<(const Array<T_numtype1, N_rank1>& d1, | | operator<(const Array<T_numtype1, N_rank1>& d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Less<T_numtype1, float> > | | Less<T_numtype1, float> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> < double | | // Array<T_numtype1, N_rank1> < double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Less<T_numtype1, double > > > | | Less<T_numtype1, double > > > | |
| operator<(const Array<T_numtype1, N_rank1>& d1, | | operator<(const Array<T_numtype1, N_rank1>& d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Less<T_numtype1, double> > | | Less<T_numtype1, double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> < long double | | // Array<T_numtype1, N_rank1> < long double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Less<T_numtype1, long double > > > | | Less<T_numtype1, long double > > > | |
| operator<(const Array<T_numtype1, N_rank1>& d1, | | operator<(const Array<T_numtype1, N_rank1>& d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Less<T_numtype1, long double> > | | Less<T_numtype1, long double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // Array<T_numtype1, N_rank1> < complex<T2> | | // Array<T_numtype1, N_rank1> < complex<T2> | |
| template<class T_numtype1, int N_rank1, class T2> | | template<class T_numtype1, int N_rank1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Less<T_numtype1, complex<T2> > > > | | Less<T_numtype1, complex<T2> > > > | |
| operator<(const Array<T_numtype1, N_rank1>& d1, | | operator<(const Array<T_numtype1, N_rank1>& d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Less<T_numtype1, complex<T2> > > | | Less<T_numtype1, complex<T2> > > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_ArrayExpr<P_expr1> < Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> < Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Less<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | Less<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator<(_bz_ArrayExpr<P_expr1> d1, | | operator<(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Less<_bz_typename P_expr1::T_numtype, T_numtype2> > | | Less<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> < _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> < _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numtype
> > > | | Less<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > > | |
| operator<(_bz_ArrayExpr<P_expr1> d1, | | operator<(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numtype
> > | | Less<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> < IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> < IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Less<_bz_typename P_expr1::T_numtype, int > > > | | Less<typename P_expr1::T_numtype, int > > > | |
| operator<(_bz_ArrayExpr<P_expr1> d1, | | operator<(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Less<_bz_typename P_expr1::T_numtype, int> > | | Less<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> < int | | // _bz_ArrayExpr<P_expr1> < int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Less<_bz_typename P_expr1::T_numtype, int > > > | | Less<typename P_expr1::T_numtype, int > > > | |
| operator<(_bz_ArrayExpr<P_expr1> d1, | | operator<(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Less<_bz_typename P_expr1::T_numtype, int> > | | Less<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> < float | | // _bz_ArrayExpr<P_expr1> < float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Less<_bz_typename P_expr1::T_numtype, float > > > | | Less<typename P_expr1::T_numtype, float > > > | |
| operator<(_bz_ArrayExpr<P_expr1> d1, | | operator<(_bz_ArrayExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Less<_bz_typename P_expr1::T_numtype, float> > | | Less<typename P_expr1::T_numtype, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> < double | | // _bz_ArrayExpr<P_expr1> < double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Less<_bz_typename P_expr1::T_numtype, double > > > | | Less<typename P_expr1::T_numtype, double > > > | |
| operator<(_bz_ArrayExpr<P_expr1> d1, | | operator<(_bz_ArrayExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Less<_bz_typename P_expr1::T_numtype, double> > | | Less<typename P_expr1::T_numtype, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> < long double | | // _bz_ArrayExpr<P_expr1> < long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Less<_bz_typename P_expr1::T_numtype, long double > > > | | Less<typename P_expr1::T_numtype, long double > > > | |
| operator<(_bz_ArrayExpr<P_expr1> d1, | | operator<(_bz_ArrayExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Less<_bz_typename P_expr1::T_numtype, long double> > | | Less<typename P_expr1::T_numtype, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // _bz_ArrayExpr<P_expr1> < complex<T2> | | // _bz_ArrayExpr<P_expr1> < complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Less<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | Less<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator<(_bz_ArrayExpr<P_expr1> d1, | | operator<(_bz_ArrayExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Less<_bz_typename P_expr1::T_numtype, complex<T2> > > | | Less<typename P_expr1::T_numtype, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // IndexPlaceholder<N_index1> < Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> < Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<int, T_numtype2 > > > | | Less<int, T_numtype2 > > > | |
| operator<(IndexPlaceholder<N_index1> d1, | | operator<(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<int, T_numtype2> > | | Less<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> < _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> < _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<int, _bz_typename P_expr2::T_numtype > > > | | Less<int, typename P_expr2::T_numtype > > > | |
| operator<(IndexPlaceholder<N_index1> d1, | | operator<(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<int, _bz_typename P_expr2::T_numtype> > | | Less<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> < IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> < IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<int, int > > > | | Less<int, int > > > | |
| operator<(IndexPlaceholder<N_index1> d1, | | operator<(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<int, int> > | | Less<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> < int | | // IndexPlaceholder<N_index1> < int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Less<int, int > > > | | Less<int, int > > > | |
| operator<(IndexPlaceholder<N_index1> d1, | | operator<(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Less<int, int> > | | Less<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> < float | | // IndexPlaceholder<N_index1> < float | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Less<int, float > > > | | Less<int, float > > > | |
| operator<(IndexPlaceholder<N_index1> d1, | | operator<(IndexPlaceholder<N_index1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Less<int, float> > | | Less<int, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> < double | | // IndexPlaceholder<N_index1> < double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Less<int, double > > > | | Less<int, double > > > | |
| operator<(IndexPlaceholder<N_index1> d1, | | operator<(IndexPlaceholder<N_index1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Less<int, double> > | | Less<int, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> < long double | | // IndexPlaceholder<N_index1> < long double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Less<int, long double > > > | | Less<int, long double > > > | |
| operator<(IndexPlaceholder<N_index1> d1, | | operator<(IndexPlaceholder<N_index1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Less<int, long double> > | | Less<int, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // IndexPlaceholder<N_index1> < complex<T2> | | // IndexPlaceholder<N_index1> < complex<T2> | |
| template<int N_index1, class T2> | | template<int N_index1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Less<int, complex<T2> > > > | | Less<int, complex<T2> > > > | |
| operator<(IndexPlaceholder<N_index1> d1, | | operator<(IndexPlaceholder<N_index1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Less<int, complex<T2> > > | | Less<int, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int < Array<T_numtype2, N_rank2> | | // int < Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<int, T_numtype2 > > > | | Less<int, T_numtype2 > > > | |
| operator<(int d1, | | operator<(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<int, T_numtype2> > | | Less<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int < _bz_ArrayExpr<P_expr2> | | // int < _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<int, _bz_typename P_expr2::T_numtype > > > | | Less<int, typename P_expr2::T_numtype > > > | |
| operator<(int d1, | | operator<(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<int, _bz_typename P_expr2::T_numtype> > | | Less<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int < IndexPlaceholder<N_index2> | | // int < IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<int, int > > > | | Less<int, int > > > | |
| operator<(int d1, | | operator<(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<int, int> > | | Less<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float < Array<T_numtype2, N_rank2> | | // float < Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<float, T_numtype2 > > > | | Less<float, T_numtype2 > > > | |
| operator<(float d1, | | operator<(float d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<float, T_numtype2> > | | Less<float, T_numtype2> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // float < _bz_ArrayExpr<P_expr2> | | // float < _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<float, _bz_typename P_expr2::T_numtype > > > | | Less<float, typename P_expr2::T_numtype > > > | |
| operator<(float d1, | | operator<(float d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<float, _bz_typename P_expr2::T_numtype> > | | Less<float, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float < IndexPlaceholder<N_index2> | | // float < IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<float, int > > > | | Less<float, int > > > | |
| operator<(float d1, | | operator<(float d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<float, int> > | | Less<float, int> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double < Array<T_numtype2, N_rank2> | | // double < Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<double, T_numtype2 > > > | | Less<double, T_numtype2 > > > | |
| operator<(double d1, | | operator<(double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<double, T_numtype2> > | | Less<double, T_numtype2> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // double < _bz_ArrayExpr<P_expr2> | | // double < _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<double, _bz_typename P_expr2::T_numtype > > > | | Less<double, typename P_expr2::T_numtype > > > | |
| operator<(double d1, | | operator<(double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<double, _bz_typename P_expr2::T_numtype> > | | Less<double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double < IndexPlaceholder<N_index2> | | // double < IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<double, int > > > | | Less<double, int > > > | |
| operator<(double d1, | | operator<(double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<double, int> > | | Less<double, int> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double < Array<T_numtype2, N_rank2> | | // long double < Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<long double, T_numtype2 > > > | | Less<long double, T_numtype2 > > > | |
| operator<(long double d1, | | operator<(long double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<long double, T_numtype2> > | | Less<long double, T_numtype2> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // long double < _bz_ArrayExpr<P_expr2> | | // long double < _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<long double, _bz_typename P_expr2::T_numtype > > > | | Less<long double, typename P_expr2::T_numtype > > > | |
| operator<(long double d1, | | operator<(long double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<long double, _bz_typename P_expr2::T_numtype> > | | Less<long double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double < IndexPlaceholder<N_index2> | | // long double < IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<long double, int > > > | | Less<long double, int > > > | |
| operator<(long double d1, | | operator<(long double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<long double, int> > | | Less<long double, int> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> < Array<T_numtype2, N_rank2> | | // complex<T1> < Array<T_numtype2, N_rank2> | |
| template<class T1, class T_numtype2, int N_rank2> | | template<class T1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<complex<T1> , T_numtype2 > > > | | Less<complex<T1> , T_numtype2 > > > | |
| operator<(complex<T1> d1, | | operator<(complex<T1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Less<complex<T1> , T_numtype2> > | | Less<complex<T1> , T_numtype2> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> < _bz_ArrayExpr<P_expr2> | | // complex<T1> < _bz_ArrayExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | Less<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator<(complex<T1> d1, | | operator<(complex<T1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Less<complex<T1> , _bz_typename P_expr2::T_numtype> > | | Less<complex<T1> , typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> < IndexPlaceholder<N_index2> | | // complex<T1> < IndexPlaceholder<N_index2> | |
| template<class T1, int N_index2> | | template<class T1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<complex<T1> , int > > > | | Less<complex<T1> , int > > > | |
| operator<(complex<T1> d1, | | operator<(complex<T1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Less<complex<T1> , int> > | | Less<complex<T1> , int> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Greater or equal (>=) operators | | * Greater or equal (>=) operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> >= Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> >= Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<T_numtype1, T_numtype2 > > > | | GreaterOrEqual<T_numtype1, T_numtype2 > > > | |
| operator>=(const Array<T_numtype1, N_rank1>& d1, | | operator>=(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<T_numtype1, T_numtype2> > | | GreaterOrEqual<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> >= _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> >= _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | GreaterOrEqual<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator>=(const Array<T_numtype1, N_rank1>& d1, | | operator>=(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<T_numtype1, _bz_typename P_expr2::T_numtype> > | | GreaterOrEqual<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> >= IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> >= IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<T_numtype1, int > > > | | GreaterOrEqual<T_numtype1, int > > > | |
| operator>=(const Array<T_numtype1, N_rank1>& d1, | | operator>=(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<T_numtype1, int> > | | GreaterOrEqual<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> >= int | | // Array<T_numtype1, N_rank1> >= int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| GreaterOrEqual<T_numtype1, int > > > | | GreaterOrEqual<T_numtype1, int > > > | |
| operator>=(const Array<T_numtype1, N_rank1>& d1, | | operator>=(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| GreaterOrEqual<T_numtype1, int> > | | GreaterOrEqual<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> >= float | | // Array<T_numtype1, N_rank1> >= float | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| GreaterOrEqual<T_numtype1, float > > > | | GreaterOrEqual<T_numtype1, float > > > | |
| operator>=(const Array<T_numtype1, N_rank1>& d1, | | operator>=(const Array<T_numtype1, N_rank1>& d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| GreaterOrEqual<T_numtype1, float> > | | GreaterOrEqual<T_numtype1, float> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> >= double | | // Array<T_numtype1, N_rank1> >= double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| GreaterOrEqual<T_numtype1, double > > > | | GreaterOrEqual<T_numtype1, double > > > | |
| operator>=(const Array<T_numtype1, N_rank1>& d1, | | operator>=(const Array<T_numtype1, N_rank1>& d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| GreaterOrEqual<T_numtype1, double> > | | GreaterOrEqual<T_numtype1, double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> >= long double | | // Array<T_numtype1, N_rank1> >= long double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| GreaterOrEqual<T_numtype1, long double > > > | | GreaterOrEqual<T_numtype1, long double > > > | |
| operator>=(const Array<T_numtype1, N_rank1>& d1, | | operator>=(const Array<T_numtype1, N_rank1>& d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| GreaterOrEqual<T_numtype1, long double> > | | GreaterOrEqual<T_numtype1, long double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // Array<T_numtype1, N_rank1> >= complex<T2> | | // Array<T_numtype1, N_rank1> >= complex<T2> | |
| template<class T_numtype1, int N_rank1, class T2> | | template<class T_numtype1, int N_rank1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| GreaterOrEqual<T_numtype1, complex<T2> > > > | | GreaterOrEqual<T_numtype1, complex<T2> > > > | |
| operator>=(const Array<T_numtype1, N_rank1>& d1, | | operator>=(const Array<T_numtype1, N_rank1>& d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| GreaterOrEqual<T_numtype1, complex<T2> > > | | GreaterOrEqual<T_numtype1, complex<T2> > > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >= Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> >= Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | GreaterOrEqual<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator>=(_bz_ArrayExpr<P_expr1> d1, | | operator>=(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, T_numtype2> > | | GreaterOrEqual<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >= _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> >= _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2:
:T_numtype > > > | | GreaterOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numty
pe > > > | |
| operator>=(_bz_ArrayExpr<P_expr1> d1, | | operator>=(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2:
:T_numtype> > | | GreaterOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numty
pe> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >= IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> >= IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, int > > > | | GreaterOrEqual<typename P_expr1::T_numtype, int > > > | |
| operator>=(_bz_ArrayExpr<P_expr1> d1, | | operator>=(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, int> > | | GreaterOrEqual<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >= int | | // _bz_ArrayExpr<P_expr1> >= int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, int > > > | | GreaterOrEqual<typename P_expr1::T_numtype, int > > > | |
| operator>=(_bz_ArrayExpr<P_expr1> d1, | | operator>=(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, int> > | | GreaterOrEqual<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >= float | | // _bz_ArrayExpr<P_expr1> >= float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, float > > > | | GreaterOrEqual<typename P_expr1::T_numtype, float > > > | |
| operator>=(_bz_ArrayExpr<P_expr1> d1, | | operator>=(_bz_ArrayExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, float> > | | GreaterOrEqual<typename P_expr1::T_numtype, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >= double | | // _bz_ArrayExpr<P_expr1> >= double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, double > > > | | GreaterOrEqual<typename P_expr1::T_numtype, double > > > | |
| operator>=(_bz_ArrayExpr<P_expr1> d1, | | operator>=(_bz_ArrayExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, double> > | | GreaterOrEqual<typename P_expr1::T_numtype, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >= long double | | // _bz_ArrayExpr<P_expr1> >= long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, long double > > > | | GreaterOrEqual<typename P_expr1::T_numtype, long double > > > | |
| operator>=(_bz_ArrayExpr<P_expr1> d1, | | operator>=(_bz_ArrayExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, long double> > | | GreaterOrEqual<typename P_expr1::T_numtype, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // _bz_ArrayExpr<P_expr1> >= complex<T2> | | // _bz_ArrayExpr<P_expr1> >= complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | GreaterOrEqual<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator>=(_bz_ArrayExpr<P_expr1> d1, | | operator>=(_bz_ArrayExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| GreaterOrEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > | | GreaterOrEqual<typename P_expr1::T_numtype, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // IndexPlaceholder<N_index1> >= Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> >= Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<int, T_numtype2 > > > | | GreaterOrEqual<int, T_numtype2 > > > | |
| operator>=(IndexPlaceholder<N_index1> d1, | | operator>=(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<int, T_numtype2> > | | GreaterOrEqual<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> >= _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> >= _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<int, _bz_typename P_expr2::T_numtype > > > | | GreaterOrEqual<int, typename P_expr2::T_numtype > > > | |
| operator>=(IndexPlaceholder<N_index1> d1, | | operator>=(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<int, _bz_typename P_expr2::T_numtype> > | | GreaterOrEqual<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> >= IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> >= IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<int, int > > > | | GreaterOrEqual<int, int > > > | |
| operator>=(IndexPlaceholder<N_index1> d1, | | operator>=(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<int, int> > | | GreaterOrEqual<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> >= int | | // IndexPlaceholder<N_index1> >= int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| GreaterOrEqual<int, int > > > | | GreaterOrEqual<int, int > > > | |
| operator>=(IndexPlaceholder<N_index1> d1, | | operator>=(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| GreaterOrEqual<int, int> > | | GreaterOrEqual<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> >= float | | // IndexPlaceholder<N_index1> >= float | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| GreaterOrEqual<int, float > > > | | GreaterOrEqual<int, float > > > | |
| operator>=(IndexPlaceholder<N_index1> d1, | | operator>=(IndexPlaceholder<N_index1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| GreaterOrEqual<int, float> > | | GreaterOrEqual<int, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> >= double | | // IndexPlaceholder<N_index1> >= double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| GreaterOrEqual<int, double > > > | | GreaterOrEqual<int, double > > > | |
| operator>=(IndexPlaceholder<N_index1> d1, | | operator>=(IndexPlaceholder<N_index1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| GreaterOrEqual<int, double> > | | GreaterOrEqual<int, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> >= long double | | // IndexPlaceholder<N_index1> >= long double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| GreaterOrEqual<int, long double > > > | | GreaterOrEqual<int, long double > > > | |
| operator>=(IndexPlaceholder<N_index1> d1, | | operator>=(IndexPlaceholder<N_index1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| GreaterOrEqual<int, long double> > | | GreaterOrEqual<int, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // IndexPlaceholder<N_index1> >= complex<T2> | | // IndexPlaceholder<N_index1> >= complex<T2> | |
| template<int N_index1, class T2> | | template<int N_index1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| GreaterOrEqual<int, complex<T2> > > > | | GreaterOrEqual<int, complex<T2> > > > | |
| operator>=(IndexPlaceholder<N_index1> d1, | | operator>=(IndexPlaceholder<N_index1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| GreaterOrEqual<int, complex<T2> > > | | GreaterOrEqual<int, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int >= Array<T_numtype2, N_rank2> | | // int >= Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<int, T_numtype2 > > > | | GreaterOrEqual<int, T_numtype2 > > > | |
| operator>=(int d1, | | operator>=(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<int, T_numtype2> > | | GreaterOrEqual<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int >= _bz_ArrayExpr<P_expr2> | | // int >= _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<int, _bz_typename P_expr2::T_numtype > > > | | GreaterOrEqual<int, typename P_expr2::T_numtype > > > | |
| operator>=(int d1, | | operator>=(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<int, _bz_typename P_expr2::T_numtype> > | | GreaterOrEqual<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int >= IndexPlaceholder<N_index2> | | // int >= IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<int, int > > > | | GreaterOrEqual<int, int > > > | |
| operator>=(int d1, | | operator>=(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<int, int> > | | GreaterOrEqual<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float >= Array<T_numtype2, N_rank2> | | // float >= Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<float, T_numtype2 > > > | | GreaterOrEqual<float, T_numtype2 > > > | |
| operator>=(float d1, | | operator>=(float d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<float, T_numtype2> > | | GreaterOrEqual<float, T_numtype2> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // float >= _bz_ArrayExpr<P_expr2> | | // float >= _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<float, _bz_typename P_expr2::T_numtype > > > | | GreaterOrEqual<float, typename P_expr2::T_numtype > > > | |
| operator>=(float d1, | | operator>=(float d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<float, _bz_typename P_expr2::T_numtype> > | | GreaterOrEqual<float, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float >= IndexPlaceholder<N_index2> | | // float >= IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<float, int > > > | | GreaterOrEqual<float, int > > > | |
| operator>=(float d1, | | operator>=(float d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<float, int> > | | GreaterOrEqual<float, int> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double >= Array<T_numtype2, N_rank2> | | // double >= Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<double, T_numtype2 > > > | | GreaterOrEqual<double, T_numtype2 > > > | |
| operator>=(double d1, | | operator>=(double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<double, T_numtype2> > | | GreaterOrEqual<double, T_numtype2> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // double >= _bz_ArrayExpr<P_expr2> | | // double >= _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<double, _bz_typename P_expr2::T_numtype > > > | | GreaterOrEqual<double, typename P_expr2::T_numtype > > > | |
| operator>=(double d1, | | operator>=(double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<double, _bz_typename P_expr2::T_numtype> > | | GreaterOrEqual<double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double >= IndexPlaceholder<N_index2> | | // double >= IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<double, int > > > | | GreaterOrEqual<double, int > > > | |
| operator>=(double d1, | | operator>=(double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<double, int> > | | GreaterOrEqual<double, int> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double >= Array<T_numtype2, N_rank2> | | // long double >= Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<long double, T_numtype2 > > > | | GreaterOrEqual<long double, T_numtype2 > > > | |
| operator>=(long double d1, | | operator>=(long double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<long double, T_numtype2> > | | GreaterOrEqual<long double, T_numtype2> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // long double >= _bz_ArrayExpr<P_expr2> | | // long double >= _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<long double, _bz_typename P_expr2::T_numtype > > > | | GreaterOrEqual<long double, typename P_expr2::T_numtype > > > | |
| operator>=(long double d1, | | operator>=(long double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<long double, _bz_typename P_expr2::T_numtype> > | | GreaterOrEqual<long double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double >= IndexPlaceholder<N_index2> | | // long double >= IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<long double, int > > > | | GreaterOrEqual<long double, int > > > | |
| operator>=(long double d1, | | operator>=(long double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<long double, int> > | | GreaterOrEqual<long double, int> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> >= Array<T_numtype2, N_rank2> | | // complex<T1> >= Array<T_numtype2, N_rank2> | |
| template<class T1, class T_numtype2, int N_rank2> | | template<class T1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<complex<T1> , T_numtype2 > > > | | GreaterOrEqual<complex<T1> , T_numtype2 > > > | |
| operator>=(complex<T1> d1, | | operator>=(complex<T1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| GreaterOrEqual<complex<T1> , T_numtype2> > | | GreaterOrEqual<complex<T1> , T_numtype2> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> >= _bz_ArrayExpr<P_expr2> | | // complex<T1> >= _bz_ArrayExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | GreaterOrEqual<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator>=(complex<T1> d1, | | operator>=(complex<T1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| GreaterOrEqual<complex<T1> , _bz_typename P_expr2::T_numtype> > | | GreaterOrEqual<complex<T1> , typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> >= IndexPlaceholder<N_index2> | | // complex<T1> >= IndexPlaceholder<N_index2> | |
| template<class T1, int N_index2> | | template<class T1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<complex<T1> , int > > > | | GreaterOrEqual<complex<T1> , int > > > | |
| operator>=(complex<T1> d1, | | operator>=(complex<T1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| GreaterOrEqual<complex<T1> , int> > | | GreaterOrEqual<complex<T1> , int> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Less or equal (<=) operators | | * Less or equal (<=) operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> <= Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> <= Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<T_numtype1, T_numtype2 > > > | | LessOrEqual<T_numtype1, T_numtype2 > > > | |
| operator<=(const Array<T_numtype1, N_rank1>& d1, | | operator<=(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<T_numtype1, T_numtype2> > | | LessOrEqual<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> <= _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> <= _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | LessOrEqual<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator<=(const Array<T_numtype1, N_rank1>& d1, | | operator<=(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<T_numtype1, _bz_typename P_expr2::T_numtype> > | | LessOrEqual<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> <= IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> <= IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<T_numtype1, int > > > | | LessOrEqual<T_numtype1, int > > > | |
| operator<=(const Array<T_numtype1, N_rank1>& d1, | | operator<=(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<T_numtype1, int> > | | LessOrEqual<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> <= int | | // Array<T_numtype1, N_rank1> <= int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LessOrEqual<T_numtype1, int > > > | | LessOrEqual<T_numtype1, int > > > | |
| operator<=(const Array<T_numtype1, N_rank1>& d1, | | operator<=(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LessOrEqual<T_numtype1, int> > | | LessOrEqual<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> <= float | | // Array<T_numtype1, N_rank1> <= float | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| LessOrEqual<T_numtype1, float > > > | | LessOrEqual<T_numtype1, float > > > | |
| operator<=(const Array<T_numtype1, N_rank1>& d1, | | operator<=(const Array<T_numtype1, N_rank1>& d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| LessOrEqual<T_numtype1, float> > | | LessOrEqual<T_numtype1, float> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> <= double | | // Array<T_numtype1, N_rank1> <= double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| LessOrEqual<T_numtype1, double > > > | | LessOrEqual<T_numtype1, double > > > | |
| operator<=(const Array<T_numtype1, N_rank1>& d1, | | operator<=(const Array<T_numtype1, N_rank1>& d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| LessOrEqual<T_numtype1, double> > | | LessOrEqual<T_numtype1, double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> <= long double | | // Array<T_numtype1, N_rank1> <= long double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| LessOrEqual<T_numtype1, long double > > > | | LessOrEqual<T_numtype1, long double > > > | |
| operator<=(const Array<T_numtype1, N_rank1>& d1, | | operator<=(const Array<T_numtype1, N_rank1>& d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| LessOrEqual<T_numtype1, long double> > | | LessOrEqual<T_numtype1, long double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // Array<T_numtype1, N_rank1> <= complex<T2> | | // Array<T_numtype1, N_rank1> <= complex<T2> | |
| template<class T_numtype1, int N_rank1, class T2> | | template<class T_numtype1, int N_rank1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| LessOrEqual<T_numtype1, complex<T2> > > > | | LessOrEqual<T_numtype1, complex<T2> > > > | |
| operator<=(const Array<T_numtype1, N_rank1>& d1, | | operator<=(const Array<T_numtype1, N_rank1>& d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| LessOrEqual<T_numtype1, complex<T2> > > | | LessOrEqual<T_numtype1, complex<T2> > > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_ArrayExpr<P_expr1> <= Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> <= Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | LessOrEqual<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator<=(_bz_ArrayExpr<P_expr1> d1, | | operator<=(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, T_numtype2> > | | LessOrEqual<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> <= _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> <= _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_
numtype > > > | | LessOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype
> > > | |
| operator<=(_bz_ArrayExpr<P_expr1> d1, | | operator<=(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_
numtype> > | | LessOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype>
> | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> <= IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> <= IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, int > > > | | LessOrEqual<typename P_expr1::T_numtype, int > > > | |
| operator<=(_bz_ArrayExpr<P_expr1> d1, | | operator<=(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, int> > | | LessOrEqual<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> <= int | | // _bz_ArrayExpr<P_expr1> <= int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, int > > > | | LessOrEqual<typename P_expr1::T_numtype, int > > > | |
| operator<=(_bz_ArrayExpr<P_expr1> d1, | | operator<=(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, int> > | | LessOrEqual<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> <= float | | // _bz_ArrayExpr<P_expr1> <= float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, float > > > | | LessOrEqual<typename P_expr1::T_numtype, float > > > | |
| operator<=(_bz_ArrayExpr<P_expr1> d1, | | operator<=(_bz_ArrayExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, float> > | | LessOrEqual<typename P_expr1::T_numtype, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> <= double | | // _bz_ArrayExpr<P_expr1> <= double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, double > > > | | LessOrEqual<typename P_expr1::T_numtype, double > > > | |
| operator<=(_bz_ArrayExpr<P_expr1> d1, | | operator<=(_bz_ArrayExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, double> > | | LessOrEqual<typename P_expr1::T_numtype, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> <= long double | | // _bz_ArrayExpr<P_expr1> <= long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, long double > > > | | LessOrEqual<typename P_expr1::T_numtype, long double > > > | |
| operator<=(_bz_ArrayExpr<P_expr1> d1, | | operator<=(_bz_ArrayExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, long double> > | | LessOrEqual<typename P_expr1::T_numtype, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // _bz_ArrayExpr<P_expr1> <= complex<T2> | | // _bz_ArrayExpr<P_expr1> <= complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | LessOrEqual<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator<=(_bz_ArrayExpr<P_expr1> d1, | | operator<=(_bz_ArrayExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| LessOrEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > | | LessOrEqual<typename P_expr1::T_numtype, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // IndexPlaceholder<N_index1> <= Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> <= Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<int, T_numtype2 > > > | | LessOrEqual<int, T_numtype2 > > > | |
| operator<=(IndexPlaceholder<N_index1> d1, | | operator<=(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<int, T_numtype2> > | | LessOrEqual<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> <= _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> <= _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<int, _bz_typename P_expr2::T_numtype > > > | | LessOrEqual<int, typename P_expr2::T_numtype > > > | |
| operator<=(IndexPlaceholder<N_index1> d1, | | operator<=(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<int, _bz_typename P_expr2::T_numtype> > | | LessOrEqual<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> <= IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> <= IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<int, int > > > | | LessOrEqual<int, int > > > | |
| operator<=(IndexPlaceholder<N_index1> d1, | | operator<=(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<int, int> > | | LessOrEqual<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> <= int | | // IndexPlaceholder<N_index1> <= int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LessOrEqual<int, int > > > | | LessOrEqual<int, int > > > | |
| operator<=(IndexPlaceholder<N_index1> d1, | | operator<=(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LessOrEqual<int, int> > | | LessOrEqual<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> <= float | | // IndexPlaceholder<N_index1> <= float | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| LessOrEqual<int, float > > > | | LessOrEqual<int, float > > > | |
| operator<=(IndexPlaceholder<N_index1> d1, | | operator<=(IndexPlaceholder<N_index1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| LessOrEqual<int, float> > | | LessOrEqual<int, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> <= double | | // IndexPlaceholder<N_index1> <= double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| LessOrEqual<int, double > > > | | LessOrEqual<int, double > > > | |
| operator<=(IndexPlaceholder<N_index1> d1, | | operator<=(IndexPlaceholder<N_index1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| LessOrEqual<int, double> > | | LessOrEqual<int, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> <= long double | | // IndexPlaceholder<N_index1> <= long double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| LessOrEqual<int, long double > > > | | LessOrEqual<int, long double > > > | |
| operator<=(IndexPlaceholder<N_index1> d1, | | operator<=(IndexPlaceholder<N_index1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| LessOrEqual<int, long double> > | | LessOrEqual<int, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // IndexPlaceholder<N_index1> <= complex<T2> | | // IndexPlaceholder<N_index1> <= complex<T2> | |
| template<int N_index1, class T2> | | template<int N_index1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| LessOrEqual<int, complex<T2> > > > | | LessOrEqual<int, complex<T2> > > > | |
| operator<=(IndexPlaceholder<N_index1> d1, | | operator<=(IndexPlaceholder<N_index1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| LessOrEqual<int, complex<T2> > > | | LessOrEqual<int, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int <= Array<T_numtype2, N_rank2> | | // int <= Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<int, T_numtype2 > > > | | LessOrEqual<int, T_numtype2 > > > | |
| operator<=(int d1, | | operator<=(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<int, T_numtype2> > | | LessOrEqual<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int <= _bz_ArrayExpr<P_expr2> | | // int <= _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<int, _bz_typename P_expr2::T_numtype > > > | | LessOrEqual<int, typename P_expr2::T_numtype > > > | |
| operator<=(int d1, | | operator<=(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<int, _bz_typename P_expr2::T_numtype> > | | LessOrEqual<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int <= IndexPlaceholder<N_index2> | | // int <= IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<int, int > > > | | LessOrEqual<int, int > > > | |
| operator<=(int d1, | | operator<=(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<int, int> > | | LessOrEqual<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float <= Array<T_numtype2, N_rank2> | | // float <= Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<float, T_numtype2 > > > | | LessOrEqual<float, T_numtype2 > > > | |
| operator<=(float d1, | | operator<=(float d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<float, T_numtype2> > | | LessOrEqual<float, T_numtype2> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // float <= _bz_ArrayExpr<P_expr2> | | // float <= _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<float, _bz_typename P_expr2::T_numtype > > > | | LessOrEqual<float, typename P_expr2::T_numtype > > > | |
| operator<=(float d1, | | operator<=(float d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<float, _bz_typename P_expr2::T_numtype> > | | LessOrEqual<float, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float <= IndexPlaceholder<N_index2> | | // float <= IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<float, int > > > | | LessOrEqual<float, int > > > | |
| operator<=(float d1, | | operator<=(float d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<float, int> > | | LessOrEqual<float, int> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double <= Array<T_numtype2, N_rank2> | | // double <= Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<double, T_numtype2 > > > | | LessOrEqual<double, T_numtype2 > > > | |
| operator<=(double d1, | | operator<=(double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<double, T_numtype2> > | | LessOrEqual<double, T_numtype2> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // double <= _bz_ArrayExpr<P_expr2> | | // double <= _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<double, _bz_typename P_expr2::T_numtype > > > | | LessOrEqual<double, typename P_expr2::T_numtype > > > | |
| operator<=(double d1, | | operator<=(double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<double, _bz_typename P_expr2::T_numtype> > | | LessOrEqual<double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double <= IndexPlaceholder<N_index2> | | // double <= IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<double, int > > > | | LessOrEqual<double, int > > > | |
| operator<=(double d1, | | operator<=(double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<double, int> > | | LessOrEqual<double, int> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double <= Array<T_numtype2, N_rank2> | | // long double <= Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<long double, T_numtype2 > > > | | LessOrEqual<long double, T_numtype2 > > > | |
| operator<=(long double d1, | | operator<=(long double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<long double, T_numtype2> > | | LessOrEqual<long double, T_numtype2> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // long double <= _bz_ArrayExpr<P_expr2> | | // long double <= _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<long double, _bz_typename P_expr2::T_numtype > > > | | LessOrEqual<long double, typename P_expr2::T_numtype > > > | |
| operator<=(long double d1, | | operator<=(long double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<long double, _bz_typename P_expr2::T_numtype> > | | LessOrEqual<long double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double <= IndexPlaceholder<N_index2> | | // long double <= IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<long double, int > > > | | LessOrEqual<long double, int > > > | |
| operator<=(long double d1, | | operator<=(long double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<long double, int> > | | LessOrEqual<long double, int> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> <= Array<T_numtype2, N_rank2> | | // complex<T1> <= Array<T_numtype2, N_rank2> | |
| template<class T1, class T_numtype2, int N_rank2> | | template<class T1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<complex<T1> , T_numtype2 > > > | | LessOrEqual<complex<T1> , T_numtype2 > > > | |
| operator<=(complex<T1> d1, | | operator<=(complex<T1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LessOrEqual<complex<T1> , T_numtype2> > | | LessOrEqual<complex<T1> , T_numtype2> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> <= _bz_ArrayExpr<P_expr2> | | // complex<T1> <= _bz_ArrayExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | LessOrEqual<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator<=(complex<T1> d1, | | operator<=(complex<T1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LessOrEqual<complex<T1> , _bz_typename P_expr2::T_numtype> > | | LessOrEqual<complex<T1> , typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> <= IndexPlaceholder<N_index2> | | // complex<T1> <= IndexPlaceholder<N_index2> | |
| template<class T1, int N_index2> | | template<class T1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<complex<T1> , int > > > | | LessOrEqual<complex<T1> , int > > > | |
| operator<=(complex<T1> d1, | | operator<=(complex<T1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LessOrEqual<complex<T1> , int> > | | LessOrEqual<complex<T1> , int> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Equality operators | | * Equality operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> == Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> == Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<T_numtype1, T_numtype2 > > > | | Equal<T_numtype1, T_numtype2 > > > | |
| operator==(const Array<T_numtype1, N_rank1>& d1, | | operator==(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<T_numtype1, T_numtype2> > | | Equal<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> == _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> == _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | Equal<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator==(const Array<T_numtype1, N_rank1>& d1, | | operator==(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<T_numtype1, _bz_typename P_expr2::T_numtype> > | | Equal<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> == IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> == IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<T_numtype1, int > > > | | Equal<T_numtype1, int > > > | |
| operator==(const Array<T_numtype1, N_rank1>& d1, | | operator==(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<T_numtype1, int> > | | Equal<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> == int | | // Array<T_numtype1, N_rank1> == int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Equal<T_numtype1, int > > > | | Equal<T_numtype1, int > > > | |
| operator==(const Array<T_numtype1, N_rank1>& d1, | | operator==(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Equal<T_numtype1, int> > | | Equal<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> == float | | // Array<T_numtype1, N_rank1> == float | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Equal<T_numtype1, float > > > | | Equal<T_numtype1, float > > > | |
| operator==(const Array<T_numtype1, N_rank1>& d1, | | operator==(const Array<T_numtype1, N_rank1>& d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Equal<T_numtype1, float> > | | Equal<T_numtype1, float> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> == double | | // Array<T_numtype1, N_rank1> == double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Equal<T_numtype1, double > > > | | Equal<T_numtype1, double > > > | |
| operator==(const Array<T_numtype1, N_rank1>& d1, | | operator==(const Array<T_numtype1, N_rank1>& d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Equal<T_numtype1, double> > | | Equal<T_numtype1, double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> == long double | | // Array<T_numtype1, N_rank1> == long double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Equal<T_numtype1, long double > > > | | Equal<T_numtype1, long double > > > | |
| operator==(const Array<T_numtype1, N_rank1>& d1, | | operator==(const Array<T_numtype1, N_rank1>& d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Equal<T_numtype1, long double> > | | Equal<T_numtype1, long double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // Array<T_numtype1, N_rank1> == complex<T2> | | // Array<T_numtype1, N_rank1> == complex<T2> | |
| template<class T_numtype1, int N_rank1, class T2> | | template<class T_numtype1, int N_rank1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Equal<T_numtype1, complex<T2> > > > | | Equal<T_numtype1, complex<T2> > > > | |
| operator==(const Array<T_numtype1, N_rank1>& d1, | | operator==(const Array<T_numtype1, N_rank1>& d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Equal<T_numtype1, complex<T2> > > | | Equal<T_numtype1, complex<T2> > > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_ArrayExpr<P_expr1> == Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> == Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | Equal<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator==(_bz_ArrayExpr<P_expr1> d1, | | operator==(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, T_numtype2> > | | Equal<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> == _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> == _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numtyp
e > > > | | Equal<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > > | |
| operator==(_bz_ArrayExpr<P_expr1> d1, | | operator==(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numtyp
e> > | | Equal<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> == IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> == IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, int > > > | | Equal<typename P_expr1::T_numtype, int > > > | |
| operator==(_bz_ArrayExpr<P_expr1> d1, | | operator==(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, int> > | | Equal<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> == int | | // _bz_ArrayExpr<P_expr1> == int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, int > > > | | Equal<typename P_expr1::T_numtype, int > > > | |
| operator==(_bz_ArrayExpr<P_expr1> d1, | | operator==(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, int> > | | Equal<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> == float | | // _bz_ArrayExpr<P_expr1> == float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, float > > > | | Equal<typename P_expr1::T_numtype, float > > > | |
| operator==(_bz_ArrayExpr<P_expr1> d1, | | operator==(_bz_ArrayExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, float> > | | Equal<typename P_expr1::T_numtype, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> == double | | // _bz_ArrayExpr<P_expr1> == double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, double > > > | | Equal<typename P_expr1::T_numtype, double > > > | |
| operator==(_bz_ArrayExpr<P_expr1> d1, | | operator==(_bz_ArrayExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, double> > | | Equal<typename P_expr1::T_numtype, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> == long double | | // _bz_ArrayExpr<P_expr1> == long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, long double > > > | | Equal<typename P_expr1::T_numtype, long double > > > | |
| operator==(_bz_ArrayExpr<P_expr1> d1, | | operator==(_bz_ArrayExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| Equal<_bz_typename P_expr1::T_numtype, long double> > | | Equal<typename P_expr1::T_numtype, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // _bz_ArrayExpr<P_expr1> == complex<T2> | | // _bz_ArrayExpr<P_expr1> == complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Equal<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | Equal<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator==(_bz_ArrayExpr<P_expr1> d1, | | operator==(_bz_ArrayExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| Equal<_bz_typename P_expr1::T_numtype, complex<T2> > > | | Equal<typename P_expr1::T_numtype, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // IndexPlaceholder<N_index1> == Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> == Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<int, T_numtype2 > > > | | Equal<int, T_numtype2 > > > | |
| operator==(IndexPlaceholder<N_index1> d1, | | operator==(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<int, T_numtype2> > | | Equal<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> == _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> == _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<int, _bz_typename P_expr2::T_numtype > > > | | Equal<int, typename P_expr2::T_numtype > > > | |
| operator==(IndexPlaceholder<N_index1> d1, | | operator==(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<int, _bz_typename P_expr2::T_numtype> > | | Equal<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> == IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> == IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<int, int > > > | | Equal<int, int > > > | |
| operator==(IndexPlaceholder<N_index1> d1, | | operator==(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<int, int> > | | Equal<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> == int | | // IndexPlaceholder<N_index1> == int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Equal<int, int > > > | | Equal<int, int > > > | |
| operator==(IndexPlaceholder<N_index1> d1, | | operator==(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| Equal<int, int> > | | Equal<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> == float | | // IndexPlaceholder<N_index1> == float | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Equal<int, float > > > | | Equal<int, float > > > | |
| operator==(IndexPlaceholder<N_index1> d1, | | operator==(IndexPlaceholder<N_index1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| Equal<int, float> > | | Equal<int, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> == double | | // IndexPlaceholder<N_index1> == double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Equal<int, double > > > | | Equal<int, double > > > | |
| operator==(IndexPlaceholder<N_index1> d1, | | operator==(IndexPlaceholder<N_index1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| Equal<int, double> > | | Equal<int, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> == long double | | // IndexPlaceholder<N_index1> == long double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Equal<int, long double > > > | | Equal<int, long double > > > | |
| operator==(IndexPlaceholder<N_index1> d1, | | operator==(IndexPlaceholder<N_index1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| Equal<int, long double> > | | Equal<int, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // IndexPlaceholder<N_index1> == complex<T2> | | // IndexPlaceholder<N_index1> == complex<T2> | |
| template<int N_index1, class T2> | | template<int N_index1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Equal<int, complex<T2> > > > | | Equal<int, complex<T2> > > > | |
| operator==(IndexPlaceholder<N_index1> d1, | | operator==(IndexPlaceholder<N_index1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| Equal<int, complex<T2> > > | | Equal<int, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int == Array<T_numtype2, N_rank2> | | // int == Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<int, T_numtype2 > > > | | Equal<int, T_numtype2 > > > | |
| operator==(int d1, | | operator==(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<int, T_numtype2> > | | Equal<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int == _bz_ArrayExpr<P_expr2> | | // int == _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<int, _bz_typename P_expr2::T_numtype > > > | | Equal<int, typename P_expr2::T_numtype > > > | |
| operator==(int d1, | | operator==(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<int, _bz_typename P_expr2::T_numtype> > | | Equal<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int == IndexPlaceholder<N_index2> | | // int == IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<int, int > > > | | Equal<int, int > > > | |
| operator==(int d1, | | operator==(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<int, int> > | | Equal<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float == Array<T_numtype2, N_rank2> | | // float == Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<float, T_numtype2 > > > | | Equal<float, T_numtype2 > > > | |
| operator==(float d1, | | operator==(float d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<float, T_numtype2> > | | Equal<float, T_numtype2> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // float == _bz_ArrayExpr<P_expr2> | | // float == _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<float, _bz_typename P_expr2::T_numtype > > > | | Equal<float, typename P_expr2::T_numtype > > > | |
| operator==(float d1, | | operator==(float d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<float, _bz_typename P_expr2::T_numtype> > | | Equal<float, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float == IndexPlaceholder<N_index2> | | // float == IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<float, int > > > | | Equal<float, int > > > | |
| operator==(float d1, | | operator==(float d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<float, int> > | | Equal<float, int> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double == Array<T_numtype2, N_rank2> | | // double == Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<double, T_numtype2 > > > | | Equal<double, T_numtype2 > > > | |
| operator==(double d1, | | operator==(double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<double, T_numtype2> > | | Equal<double, T_numtype2> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // double == _bz_ArrayExpr<P_expr2> | | // double == _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<double, _bz_typename P_expr2::T_numtype > > > | | Equal<double, typename P_expr2::T_numtype > > > | |
| operator==(double d1, | | operator==(double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<double, _bz_typename P_expr2::T_numtype> > | | Equal<double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double == IndexPlaceholder<N_index2> | | // double == IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<double, int > > > | | Equal<double, int > > > | |
| operator==(double d1, | | operator==(double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<double, int> > | | Equal<double, int> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double == Array<T_numtype2, N_rank2> | | // long double == Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<long double, T_numtype2 > > > | | Equal<long double, T_numtype2 > > > | |
| operator==(long double d1, | | operator==(long double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<long double, T_numtype2> > | | Equal<long double, T_numtype2> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // long double == _bz_ArrayExpr<P_expr2> | | // long double == _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<long double, _bz_typename P_expr2::T_numtype > > > | | Equal<long double, typename P_expr2::T_numtype > > > | |
| operator==(long double d1, | | operator==(long double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<long double, _bz_typename P_expr2::T_numtype> > | | Equal<long double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double == IndexPlaceholder<N_index2> | | // long double == IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<long double, int > > > | | Equal<long double, int > > > | |
| operator==(long double d1, | | operator==(long double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<long double, int> > | | Equal<long double, int> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> == Array<T_numtype2, N_rank2> | | // complex<T1> == Array<T_numtype2, N_rank2> | |
| template<class T1, class T_numtype2, int N_rank2> | | template<class T1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<complex<T1> , T_numtype2 > > > | | Equal<complex<T1> , T_numtype2 > > > | |
| operator==(complex<T1> d1, | | operator==(complex<T1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| Equal<complex<T1> , T_numtype2> > | | Equal<complex<T1> , T_numtype2> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> == _bz_ArrayExpr<P_expr2> | | // complex<T1> == _bz_ArrayExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | Equal<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator==(complex<T1> d1, | | operator==(complex<T1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| Equal<complex<T1> , _bz_typename P_expr2::T_numtype> > | | Equal<complex<T1> , typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> == IndexPlaceholder<N_index2> | | // complex<T1> == IndexPlaceholder<N_index2> | |
| template<class T1, int N_index2> | | template<class T1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<complex<T1> , int > > > | | Equal<complex<T1> , int > > > | |
| operator==(complex<T1> d1, | | operator==(complex<T1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| Equal<complex<T1> , int> > | | Equal<complex<T1> , int> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Not-equal operators | | * Not-equal operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> != Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> != Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<T_numtype1, T_numtype2 > > > | | NotEqual<T_numtype1, T_numtype2 > > > | |
| operator!=(const Array<T_numtype1, N_rank1>& d1, | | operator!=(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<T_numtype1, T_numtype2> > | | NotEqual<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> != _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> != _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | NotEqual<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator!=(const Array<T_numtype1, N_rank1>& d1, | | operator!=(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<T_numtype1, _bz_typename P_expr2::T_numtype> > | | NotEqual<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> != IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> != IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<T_numtype1, int > > > | | NotEqual<T_numtype1, int > > > | |
| operator!=(const Array<T_numtype1, N_rank1>& d1, | | operator!=(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<T_numtype1, int> > | | NotEqual<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> != int | | // Array<T_numtype1, N_rank1> != int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| NotEqual<T_numtype1, int > > > | | NotEqual<T_numtype1, int > > > | |
| operator!=(const Array<T_numtype1, N_rank1>& d1, | | operator!=(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| NotEqual<T_numtype1, int> > | | NotEqual<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> != float | | // Array<T_numtype1, N_rank1> != float | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| NotEqual<T_numtype1, float > > > | | NotEqual<T_numtype1, float > > > | |
| operator!=(const Array<T_numtype1, N_rank1>& d1, | | operator!=(const Array<T_numtype1, N_rank1>& d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| NotEqual<T_numtype1, float> > | | NotEqual<T_numtype1, float> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> != double | | // Array<T_numtype1, N_rank1> != double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| NotEqual<T_numtype1, double > > > | | NotEqual<T_numtype1, double > > > | |
| operator!=(const Array<T_numtype1, N_rank1>& d1, | | operator!=(const Array<T_numtype1, N_rank1>& d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| NotEqual<T_numtype1, double> > | | NotEqual<T_numtype1, double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> != long double | | // Array<T_numtype1, N_rank1> != long double | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| NotEqual<T_numtype1, long double > > > | | NotEqual<T_numtype1, long double > > > | |
| operator!=(const Array<T_numtype1, N_rank1>& d1, | | operator!=(const Array<T_numtype1, N_rank1>& d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| NotEqual<T_numtype1, long double> > | | NotEqual<T_numtype1, long double> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // Array<T_numtype1, N_rank1> != complex<T2> | | // Array<T_numtype1, N_rank1> != complex<T2> | |
| template<class T_numtype1, int N_rank1, class T2> | | template<class T_numtype1, int N_rank1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| NotEqual<T_numtype1, complex<T2> > > > | | NotEqual<T_numtype1, complex<T2> > > > | |
| operator!=(const Array<T_numtype1, N_rank1>& d1, | | operator!=(const Array<T_numtype1, N_rank1>& d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| NotEqual<T_numtype1, complex<T2> > > | | NotEqual<T_numtype1, complex<T2> > > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_ArrayExpr<P_expr1> != Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> != Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | NotEqual<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator!=(_bz_ArrayExpr<P_expr1> d1, | | operator!=(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, T_numtype2> > | | NotEqual<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> != _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> != _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_num
type > > > | | NotEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype > >
> | |
| operator!=(_bz_ArrayExpr<P_expr1> d1, | | operator!=(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_num
type> > | | NotEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> != IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> != IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, int > > > | | NotEqual<typename P_expr1::T_numtype, int > > > | |
| operator!=(_bz_ArrayExpr<P_expr1> d1, | | operator!=(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, int> > | | NotEqual<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> != int | | // _bz_ArrayExpr<P_expr1> != int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, int > > > | | NotEqual<typename P_expr1::T_numtype, int > > > | |
| operator!=(_bz_ArrayExpr<P_expr1> d1, | | operator!=(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, int> > | | NotEqual<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> != float | | // _bz_ArrayExpr<P_expr1> != float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, float > > > | | NotEqual<typename P_expr1::T_numtype, float > > > | |
| operator!=(_bz_ArrayExpr<P_expr1> d1, | | operator!=(_bz_ArrayExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, float> > | | NotEqual<typename P_expr1::T_numtype, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> != double | | // _bz_ArrayExpr<P_expr1> != double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, double > > > | | NotEqual<typename P_expr1::T_numtype, double > > > | |
| operator!=(_bz_ArrayExpr<P_expr1> d1, | | operator!=(_bz_ArrayExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, double> > | | NotEqual<typename P_expr1::T_numtype, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> != long double | | // _bz_ArrayExpr<P_expr1> != long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, long double > > > | | NotEqual<typename P_expr1::T_numtype, long double > > > | |
| operator!=(_bz_ArrayExpr<P_expr1> d1, | | operator!=(_bz_ArrayExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, long double> > | | NotEqual<typename P_expr1::T_numtype, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // _bz_ArrayExpr<P_expr1> != complex<T2> | | // _bz_ArrayExpr<P_expr1> != complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | NotEqual<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator!=(_bz_ArrayExpr<P_expr1> d1, | | operator!=(_bz_ArrayExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
|
| NotEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > | | NotEqual<typename P_expr1::T_numtype, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // IndexPlaceholder<N_index1> != Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> != Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<int, T_numtype2 > > > | | NotEqual<int, T_numtype2 > > > | |
| operator!=(IndexPlaceholder<N_index1> d1, | | operator!=(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<int, T_numtype2> > | | NotEqual<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> != _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> != _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<int, _bz_typename P_expr2::T_numtype > > > | | NotEqual<int, typename P_expr2::T_numtype > > > | |
| operator!=(IndexPlaceholder<N_index1> d1, | | operator!=(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<int, _bz_typename P_expr2::T_numtype> > | | NotEqual<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> != IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> != IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<int, int > > > | | NotEqual<int, int > > > | |
| operator!=(IndexPlaceholder<N_index1> d1, | | operator!=(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<int, int> > | | NotEqual<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> != int | | // IndexPlaceholder<N_index1> != int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| NotEqual<int, int > > > | | NotEqual<int, int > > > | |
| operator!=(IndexPlaceholder<N_index1> d1, | | operator!=(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| NotEqual<int, int> > | | NotEqual<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> != float | | // IndexPlaceholder<N_index1> != float | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| NotEqual<int, float > > > | | NotEqual<int, float > > > | |
| operator!=(IndexPlaceholder<N_index1> d1, | | operator!=(IndexPlaceholder<N_index1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<float>, | | _bz_ArrayExprConstant<float>, | |
| NotEqual<int, float> > | | NotEqual<int, float> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<float>(d2)); | | _bz_ArrayExprConstant<float>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> != double | | // IndexPlaceholder<N_index1> != double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| NotEqual<int, double > > > | | NotEqual<int, double > > > | |
| operator!=(IndexPlaceholder<N_index1> d1, | | operator!=(IndexPlaceholder<N_index1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<double>, | | _bz_ArrayExprConstant<double>, | |
| NotEqual<int, double> > | | NotEqual<int, double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<double>(d2)); | | _bz_ArrayExprConstant<double>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> != long double | | // IndexPlaceholder<N_index1> != long double | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| NotEqual<int, long double > > > | | NotEqual<int, long double > > > | |
| operator!=(IndexPlaceholder<N_index1> d1, | | operator!=(IndexPlaceholder<N_index1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<long double>, | | _bz_ArrayExprConstant<long double>, | |
| NotEqual<int, long double> > | | NotEqual<int, long double> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<long double>(d2)); | | _bz_ArrayExprConstant<long double>(d2)); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // IndexPlaceholder<N_index1> != complex<T2> | | // IndexPlaceholder<N_index1> != complex<T2> | |
| template<int N_index1, class T2> | | template<int N_index1, class T2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| NotEqual<int, complex<T2> > > > | | NotEqual<int, complex<T2> > > > | |
| operator!=(IndexPlaceholder<N_index1> d1, | | operator!=(IndexPlaceholder<N_index1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<complex<T2> > , | | _bz_ArrayExprConstant<complex<T2> > , | |
| NotEqual<int, complex<T2> > > | | NotEqual<int, complex<T2> > > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<complex<T2> > (d2)); | | _bz_ArrayExprConstant<complex<T2> > (d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int != Array<T_numtype2, N_rank2> | | // int != Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<int, T_numtype2 > > > | | NotEqual<int, T_numtype2 > > > | |
| operator!=(int d1, | | operator!=(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<int, T_numtype2> > | | NotEqual<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int != _bz_ArrayExpr<P_expr2> | | // int != _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<int, _bz_typename P_expr2::T_numtype > > > | | NotEqual<int, typename P_expr2::T_numtype > > > | |
| operator!=(int d1, | | operator!=(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<int, _bz_typename P_expr2::T_numtype> > | | NotEqual<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int != IndexPlaceholder<N_index2> | | // int != IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<int, int > > > | | NotEqual<int, int > > > | |
| operator!=(int d1, | | operator!=(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<int, int> > | | NotEqual<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float != Array<T_numtype2, N_rank2> | | // float != Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<float, T_numtype2 > > > | | NotEqual<float, T_numtype2 > > > | |
| operator!=(float d1, | | operator!=(float d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<float, T_numtype2> > | | NotEqual<float, T_numtype2> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // float != _bz_ArrayExpr<P_expr2> | | // float != _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<float, _bz_typename P_expr2::T_numtype > > > | | NotEqual<float, typename P_expr2::T_numtype > > > | |
| operator!=(float d1, | | operator!=(float d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<float, _bz_typename P_expr2::T_numtype> > | | NotEqual<float, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // float != IndexPlaceholder<N_index2> | | // float != IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<float, int > > > | | NotEqual<float, int > > > | |
| operator!=(float d1, | | operator!=(float d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<float>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<float>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<float, int> > | | NotEqual<float, int> > | |
| (_bz_ArrayExprConstant<float>(d1), | | (_bz_ArrayExprConstant<float>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double != Array<T_numtype2, N_rank2> | | // double != Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<double, T_numtype2 > > > | | NotEqual<double, T_numtype2 > > > | |
| operator!=(double d1, | | operator!=(double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<double, T_numtype2> > | | NotEqual<double, T_numtype2> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // double != _bz_ArrayExpr<P_expr2> | | // double != _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<double, _bz_typename P_expr2::T_numtype > > > | | NotEqual<double, typename P_expr2::T_numtype > > > | |
| operator!=(double d1, | | operator!=(double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<double, _bz_typename P_expr2::T_numtype> > | | NotEqual<double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // double != IndexPlaceholder<N_index2> | | // double != IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<double, int > > > | | NotEqual<double, int > > > | |
| operator!=(double d1, | | operator!=(double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<double, int> > | | NotEqual<double, int> > | |
| (_bz_ArrayExprConstant<double>(d1), | | (_bz_ArrayExprConstant<double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double != Array<T_numtype2, N_rank2> | | // long double != Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<long double, T_numtype2 > > > | | NotEqual<long double, T_numtype2 > > > | |
| operator!=(long double d1, | | operator!=(long double d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<long double, T_numtype2> > | | NotEqual<long double, T_numtype2> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // long double != _bz_ArrayExpr<P_expr2> | | // long double != _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<long double, _bz_typename P_expr2::T_numtype > > > | | NotEqual<long double, typename P_expr2::T_numtype > > > | |
| operator!=(long double d1, | | operator!=(long double d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<long double, _bz_typename P_expr2::T_numtype> > | | NotEqual<long double, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // long double != IndexPlaceholder<N_index2> | | // long double != IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<long double, int > > > | | NotEqual<long double, int > > > | |
| operator!=(long double d1, | | operator!=(long double d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<long double>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<long double>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<long double, int> > | | NotEqual<long double, int> > | |
| (_bz_ArrayExprConstant<long double>(d1), | | (_bz_ArrayExprConstant<long double>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> != Array<T_numtype2, N_rank2> | | // complex<T1> != Array<T_numtype2, N_rank2> | |
| template<class T1, class T_numtype2, int N_rank2> | | template<class T1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<complex<T1> , T_numtype2 > > > | | NotEqual<complex<T1> , T_numtype2 > > > | |
| operator!=(complex<T1> d1, | | operator!=(complex<T1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| NotEqual<complex<T1> , T_numtype2> > | | NotEqual<complex<T1> , T_numtype2> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> != _bz_ArrayExpr<P_expr2> | | // complex<T1> != _bz_ArrayExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | NotEqual<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator!=(complex<T1> d1, | | operator!=(complex<T1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| NotEqual<complex<T1> , _bz_typename P_expr2::T_numtype> > | | NotEqual<complex<T1> , typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| // complex<T1> != IndexPlaceholder<N_index2> | | // complex<T1> != IndexPlaceholder<N_index2> | |
| template<class T1, int N_index2> | | template<class T1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<complex<T1> , int > > > | | NotEqual<complex<T1> , int > > > | |
| operator!=(complex<T1> d1, | | operator!=(complex<T1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<complex<T1> > , | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<complex<T1> > , | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| NotEqual<complex<T1> , int> > | | NotEqual<complex<T1> , int> > | |
| (_bz_ArrayExprConstant<complex<T1> > (d1), | | (_bz_ArrayExprConstant<complex<T1> > (d1), | |
| d2); | | d2); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Logical AND operators | | * Logical AND operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> && Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> && Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalAnd<T_numtype1, T_numtype2 > > > | | LogicalAnd<T_numtype1, T_numtype2 > > > | |
| operator&&(const Array<T_numtype1, N_rank1>& d1, | | operator&&(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalAnd<T_numtype1, T_numtype2> > | | LogicalAnd<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> && _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> && _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalAnd<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | LogicalAnd<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator&&(const Array<T_numtype1, N_rank1>& d1, | | operator&&(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalAnd<T_numtype1, _bz_typename P_expr2::T_numtype> > | | LogicalAnd<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> && IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> && IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalAnd<T_numtype1, int > > > | | LogicalAnd<T_numtype1, int > > > | |
| operator&&(const Array<T_numtype1, N_rank1>& d1, | | operator&&(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalAnd<T_numtype1, int> > | | LogicalAnd<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> && int | | // Array<T_numtype1, N_rank1> && int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LogicalAnd<T_numtype1, int > > > | | LogicalAnd<T_numtype1, int > > > | |
| operator&&(const Array<T_numtype1, N_rank1>& d1, | | operator&&(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LogicalAnd<T_numtype1, int> > | | LogicalAnd<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> && Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> && Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| LogicalAnd<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | LogicalAnd<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator&&(_bz_ArrayExpr<P_expr1> d1, | | operator&&(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| LogicalAnd<_bz_typename P_expr1::T_numtype, T_numtype2> > | | LogicalAnd<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> && _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> && _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalAnd<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_n
umtype > > > | | LogicalAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype >
> > | |
| operator&&(_bz_ArrayExpr<P_expr1> d1, | | operator&&(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalAnd<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_n
umtype> > | | LogicalAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype>
> | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> && IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> && IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| LogicalAnd<_bz_typename P_expr1::T_numtype, int > > > | | LogicalAnd<typename P_expr1::T_numtype, int > > > | |
| operator&&(_bz_ArrayExpr<P_expr1> d1, | | operator&&(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| LogicalAnd<_bz_typename P_expr1::T_numtype, int> > | | LogicalAnd<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> && int | | // _bz_ArrayExpr<P_expr1> && int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| LogicalAnd<_bz_typename P_expr1::T_numtype, int > > > | | LogicalAnd<typename P_expr1::T_numtype, int > > > | |
| operator&&(_bz_ArrayExpr<P_expr1> d1, | | operator&&(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| LogicalAnd<_bz_typename P_expr1::T_numtype, int> > | | LogicalAnd<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> && Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> && Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalAnd<int, T_numtype2 > > > | | LogicalAnd<int, T_numtype2 > > > | |
| operator&&(IndexPlaceholder<N_index1> d1, | | operator&&(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalAnd<int, T_numtype2> > | | LogicalAnd<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> && _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> && _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalAnd<int, _bz_typename P_expr2::T_numtype > > > | | LogicalAnd<int, typename P_expr2::T_numtype > > > | |
| operator&&(IndexPlaceholder<N_index1> d1, | | operator&&(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalAnd<int, _bz_typename P_expr2::T_numtype> > | | LogicalAnd<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> && IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> && IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalAnd<int, int > > > | | LogicalAnd<int, int > > > | |
| operator&&(IndexPlaceholder<N_index1> d1, | | operator&&(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalAnd<int, int> > | | LogicalAnd<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> && int | | // IndexPlaceholder<N_index1> && int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LogicalAnd<int, int > > > | | LogicalAnd<int, int > > > | |
| operator&&(IndexPlaceholder<N_index1> d1, | | operator&&(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LogicalAnd<int, int> > | | LogicalAnd<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // int && Array<T_numtype2, N_rank2> | | // int && Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalAnd<int, T_numtype2 > > > | | LogicalAnd<int, T_numtype2 > > > | |
| operator&&(int d1, | | operator&&(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalAnd<int, T_numtype2> > | | LogicalAnd<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int && _bz_ArrayExpr<P_expr2> | | // int && _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalAnd<int, _bz_typename P_expr2::T_numtype > > > | | LogicalAnd<int, typename P_expr2::T_numtype > > > | |
| operator&&(int d1, | | operator&&(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalAnd<int, _bz_typename P_expr2::T_numtype> > | | LogicalAnd<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int && IndexPlaceholder<N_index2> | | // int && IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalAnd<int, int > > > | | LogicalAnd<int, int > > > | |
| operator&&(int d1, | | operator&&(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalAnd<int, int> > | | LogicalAnd<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Logical OR operators | | * Logical OR operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> || Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> || Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalOr<T_numtype1, T_numtype2 > > > | | LogicalOr<T_numtype1, T_numtype2 > > > | |
| operator||(const Array<T_numtype1, N_rank1>& d1, | | operator||(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalOr<T_numtype1, T_numtype2> > | | LogicalOr<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> || _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> || _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalOr<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | LogicalOr<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator||(const Array<T_numtype1, N_rank1>& d1, | | operator||(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalOr<T_numtype1, _bz_typename P_expr2::T_numtype> > | | LogicalOr<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> || IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> || IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalOr<T_numtype1, int > > > | | LogicalOr<T_numtype1, int > > > | |
| operator||(const Array<T_numtype1, N_rank1>& d1, | | operator||(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalOr<T_numtype1, int> > | | LogicalOr<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> || int | | // Array<T_numtype1, N_rank1> || int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LogicalOr<T_numtype1, int > > > | | LogicalOr<T_numtype1, int > > > | |
| operator||(const Array<T_numtype1, N_rank1>& d1, | | operator||(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LogicalOr<T_numtype1, int> > | | LogicalOr<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> || Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> || Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| LogicalOr<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | LogicalOr<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator||(_bz_ArrayExpr<P_expr1> d1, | | operator||(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| LogicalOr<_bz_typename P_expr1::T_numtype, T_numtype2> > | | LogicalOr<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> || _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> || _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalOr<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_nu
mtype > > > | | LogicalOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype >
> > | |
| operator||(_bz_ArrayExpr<P_expr1> d1, | | operator||(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalOr<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_nu
mtype> > | | LogicalOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> || IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> || IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| LogicalOr<_bz_typename P_expr1::T_numtype, int > > > | | LogicalOr<typename P_expr1::T_numtype, int > > > | |
| operator||(_bz_ArrayExpr<P_expr1> d1, | | operator||(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| LogicalOr<_bz_typename P_expr1::T_numtype, int> > | | LogicalOr<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> || int | | // _bz_ArrayExpr<P_expr1> || int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| LogicalOr<_bz_typename P_expr1::T_numtype, int > > > | | LogicalOr<typename P_expr1::T_numtype, int > > > | |
| operator||(_bz_ArrayExpr<P_expr1> d1, | | operator||(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| LogicalOr<_bz_typename P_expr1::T_numtype, int> > | | LogicalOr<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> || Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> || Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalOr<int, T_numtype2 > > > | | LogicalOr<int, T_numtype2 > > > | |
| operator||(IndexPlaceholder<N_index1> d1, | | operator||(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalOr<int, T_numtype2> > | | LogicalOr<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> || _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> || _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalOr<int, _bz_typename P_expr2::T_numtype > > > | | LogicalOr<int, typename P_expr2::T_numtype > > > | |
| operator||(IndexPlaceholder<N_index1> d1, | | operator||(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalOr<int, _bz_typename P_expr2::T_numtype> > | | LogicalOr<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> || IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> || IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalOr<int, int > > > | | LogicalOr<int, int > > > | |
| operator||(IndexPlaceholder<N_index1> d1, | | operator||(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalOr<int, int> > | | LogicalOr<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> || int | | // IndexPlaceholder<N_index1> || int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LogicalOr<int, int > > > | | LogicalOr<int, int > > > | |
| operator||(IndexPlaceholder<N_index1> d1, | | operator||(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| LogicalOr<int, int> > | | LogicalOr<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // int || Array<T_numtype2, N_rank2> | | // int || Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalOr<int, T_numtype2 > > > | | LogicalOr<int, T_numtype2 > > > | |
| operator||(int d1, | | operator||(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| LogicalOr<int, T_numtype2> > | | LogicalOr<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int || _bz_ArrayExpr<P_expr2> | | // int || _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalOr<int, _bz_typename P_expr2::T_numtype > > > | | LogicalOr<int, typename P_expr2::T_numtype > > > | |
| operator||(int d1, | | operator||(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| LogicalOr<int, _bz_typename P_expr2::T_numtype> > | | LogicalOr<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int || IndexPlaceholder<N_index2> | | // int || IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalOr<int, int > > > | | LogicalOr<int, int > > > | |
| operator||(int d1, | | operator||(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| LogicalOr<int, int> > | | LogicalOr<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Bitwise XOR Operators | | * Bitwise XOR Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> ^ Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> ^ Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseXor<T_numtype1, T_numtype2 > > > | | BitwiseXor<T_numtype1, T_numtype2 > > > | |
| operator^(const Array<T_numtype1, N_rank1>& d1, | | operator^(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseXor<T_numtype1, T_numtype2> > | | BitwiseXor<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> ^ _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> ^ _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseXor<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | BitwiseXor<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator^(const Array<T_numtype1, N_rank1>& d1, | | operator^(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseXor<T_numtype1, _bz_typename P_expr2::T_numtype> > | | BitwiseXor<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> ^ IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> ^ IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseXor<T_numtype1, int > > > | | BitwiseXor<T_numtype1, int > > > | |
| operator^(const Array<T_numtype1, N_rank1>& d1, | | operator^(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseXor<T_numtype1, int> > | | BitwiseXor<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> ^ int | | // Array<T_numtype1, N_rank1> ^ int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseXor<T_numtype1, int > > > | | BitwiseXor<T_numtype1, int > > > | |
| operator^(const Array<T_numtype1, N_rank1>& d1, | | operator^(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseXor<T_numtype1, int> > | | BitwiseXor<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> ^ Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> ^ Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| BitwiseXor<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | BitwiseXor<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator^(_bz_ArrayExpr<P_expr1> d1, | | operator^(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| BitwiseXor<_bz_typename P_expr1::T_numtype, T_numtype2> > | | BitwiseXor<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> ^ _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> ^ _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseXor<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_n
umtype > > > | | BitwiseXor<typename P_expr1::T_numtype, typename P_expr2::T_numtype >
> > | |
| operator^(_bz_ArrayExpr<P_expr1> d1, | | operator^(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseXor<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_n
umtype> > | | BitwiseXor<typename P_expr1::T_numtype, typename P_expr2::T_numtype>
> | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> ^ IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> ^ IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| BitwiseXor<_bz_typename P_expr1::T_numtype, int > > > | | BitwiseXor<typename P_expr1::T_numtype, int > > > | |
| operator^(_bz_ArrayExpr<P_expr1> d1, | | operator^(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| BitwiseXor<_bz_typename P_expr1::T_numtype, int> > | | BitwiseXor<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> ^ int | | // _bz_ArrayExpr<P_expr1> ^ int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| BitwiseXor<_bz_typename P_expr1::T_numtype, int > > > | | BitwiseXor<typename P_expr1::T_numtype, int > > > | |
| operator^(_bz_ArrayExpr<P_expr1> d1, | | operator^(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| BitwiseXor<_bz_typename P_expr1::T_numtype, int> > | | BitwiseXor<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> ^ Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> ^ Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseXor<int, T_numtype2 > > > | | BitwiseXor<int, T_numtype2 > > > | |
| operator^(IndexPlaceholder<N_index1> d1, | | operator^(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseXor<int, T_numtype2> > | | BitwiseXor<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> ^ _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> ^ _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseXor<int, _bz_typename P_expr2::T_numtype > > > | | BitwiseXor<int, typename P_expr2::T_numtype > > > | |
| operator^(IndexPlaceholder<N_index1> d1, | | operator^(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseXor<int, _bz_typename P_expr2::T_numtype> > | | BitwiseXor<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> ^ IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> ^ IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseXor<int, int > > > | | BitwiseXor<int, int > > > | |
| operator^(IndexPlaceholder<N_index1> d1, | | operator^(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseXor<int, int> > | | BitwiseXor<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> ^ int | | // IndexPlaceholder<N_index1> ^ int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseXor<int, int > > > | | BitwiseXor<int, int > > > | |
| operator^(IndexPlaceholder<N_index1> d1, | | operator^(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseXor<int, int> > | | BitwiseXor<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // int ^ Array<T_numtype2, N_rank2> | | // int ^ Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseXor<int, T_numtype2 > > > | | BitwiseXor<int, T_numtype2 > > > | |
| operator^(int d1, | | operator^(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseXor<int, T_numtype2> > | | BitwiseXor<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int ^ _bz_ArrayExpr<P_expr2> | | // int ^ _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseXor<int, _bz_typename P_expr2::T_numtype > > > | | BitwiseXor<int, typename P_expr2::T_numtype > > > | |
| operator^(int d1, | | operator^(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseXor<int, _bz_typename P_expr2::T_numtype> > | | BitwiseXor<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int ^ IndexPlaceholder<N_index2> | | // int ^ IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseXor<int, int > > > | | BitwiseXor<int, int > > > | |
| operator^(int d1, | | operator^(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseXor<int, int> > | | BitwiseXor<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Bitwise And Operators | | * Bitwise And Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> & Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> & Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseAnd<T_numtype1, T_numtype2 > > > | | BitwiseAnd<T_numtype1, T_numtype2 > > > | |
| operator&(const Array<T_numtype1, N_rank1>& d1, | | operator&(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseAnd<T_numtype1, T_numtype2> > | | BitwiseAnd<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> & _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> & _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseAnd<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | BitwiseAnd<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator&(const Array<T_numtype1, N_rank1>& d1, | | operator&(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseAnd<T_numtype1, _bz_typename P_expr2::T_numtype> > | | BitwiseAnd<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> & IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> & IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseAnd<T_numtype1, int > > > | | BitwiseAnd<T_numtype1, int > > > | |
| operator&(const Array<T_numtype1, N_rank1>& d1, | | operator&(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseAnd<T_numtype1, int> > | | BitwiseAnd<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> & int | | // Array<T_numtype1, N_rank1> & int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseAnd<T_numtype1, int > > > | | BitwiseAnd<T_numtype1, int > > > | |
| operator&(const Array<T_numtype1, N_rank1>& d1, | | operator&(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseAnd<T_numtype1, int> > | | BitwiseAnd<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> & Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> & Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| BitwiseAnd<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | BitwiseAnd<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator&(_bz_ArrayExpr<P_expr1> d1, | | operator&(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| BitwiseAnd<_bz_typename P_expr1::T_numtype, T_numtype2> > | | BitwiseAnd<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> & _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> & _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseAnd<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_n
umtype > > > | | BitwiseAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype >
> > | |
| operator&(_bz_ArrayExpr<P_expr1> d1, | | operator&(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseAnd<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_n
umtype> > | | BitwiseAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype>
> | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> & IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> & IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| BitwiseAnd<_bz_typename P_expr1::T_numtype, int > > > | | BitwiseAnd<typename P_expr1::T_numtype, int > > > | |
| operator&(_bz_ArrayExpr<P_expr1> d1, | | operator&(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| BitwiseAnd<_bz_typename P_expr1::T_numtype, int> > | | BitwiseAnd<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> & int | | // _bz_ArrayExpr<P_expr1> & int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| BitwiseAnd<_bz_typename P_expr1::T_numtype, int > > > | | BitwiseAnd<typename P_expr1::T_numtype, int > > > | |
| operator&(_bz_ArrayExpr<P_expr1> d1, | | operator&(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| BitwiseAnd<_bz_typename P_expr1::T_numtype, int> > | | BitwiseAnd<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> & Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> & Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseAnd<int, T_numtype2 > > > | | BitwiseAnd<int, T_numtype2 > > > | |
| operator&(IndexPlaceholder<N_index1> d1, | | operator&(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseAnd<int, T_numtype2> > | | BitwiseAnd<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> & _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> & _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseAnd<int, _bz_typename P_expr2::T_numtype > > > | | BitwiseAnd<int, typename P_expr2::T_numtype > > > | |
| operator&(IndexPlaceholder<N_index1> d1, | | operator&(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseAnd<int, _bz_typename P_expr2::T_numtype> > | | BitwiseAnd<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> & IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> & IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseAnd<int, int > > > | | BitwiseAnd<int, int > > > | |
| operator&(IndexPlaceholder<N_index1> d1, | | operator&(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseAnd<int, int> > | | BitwiseAnd<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> & int | | // IndexPlaceholder<N_index1> & int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseAnd<int, int > > > | | BitwiseAnd<int, int > > > | |
| operator&(IndexPlaceholder<N_index1> d1, | | operator&(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseAnd<int, int> > | | BitwiseAnd<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // int & Array<T_numtype2, N_rank2> | | // int & Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseAnd<int, T_numtype2 > > > | | BitwiseAnd<int, T_numtype2 > > > | |
| operator&(int d1, | | operator&(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseAnd<int, T_numtype2> > | | BitwiseAnd<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int & _bz_ArrayExpr<P_expr2> | | // int & _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseAnd<int, _bz_typename P_expr2::T_numtype > > > | | BitwiseAnd<int, typename P_expr2::T_numtype > > > | |
| operator&(int d1, | | operator&(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseAnd<int, _bz_typename P_expr2::T_numtype> > | | BitwiseAnd<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int & IndexPlaceholder<N_index2> | | // int & IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseAnd<int, int > > > | | BitwiseAnd<int, int > > > | |
| operator&(int d1, | | operator&(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseAnd<int, int> > | | BitwiseAnd<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Bitwise Or Operators | | * Bitwise Or Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> | Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> | Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseOr<T_numtype1, T_numtype2 > > > | | BitwiseOr<T_numtype1, T_numtype2 > > > | |
| operator|(const Array<T_numtype1, N_rank1>& d1, | | operator|(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseOr<T_numtype1, T_numtype2> > | | BitwiseOr<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> | _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> | _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseOr<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | BitwiseOr<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator|(const Array<T_numtype1, N_rank1>& d1, | | operator|(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseOr<T_numtype1, _bz_typename P_expr2::T_numtype> > | | BitwiseOr<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> | IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> | IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseOr<T_numtype1, int > > > | | BitwiseOr<T_numtype1, int > > > | |
| operator|(const Array<T_numtype1, N_rank1>& d1, | | operator|(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseOr<T_numtype1, int> > | | BitwiseOr<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> | int | | // Array<T_numtype1, N_rank1> | int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseOr<T_numtype1, int > > > | | BitwiseOr<T_numtype1, int > > > | |
| operator|(const Array<T_numtype1, N_rank1>& d1, | | operator|(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseOr<T_numtype1, int> > | | BitwiseOr<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> | Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> | Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| BitwiseOr<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | BitwiseOr<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator|(_bz_ArrayExpr<P_expr1> d1, | | operator|(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| BitwiseOr<_bz_typename P_expr1::T_numtype, T_numtype2> > | | BitwiseOr<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> | _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> | _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseOr<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_nu
mtype > > > | | BitwiseOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype >
> > | |
| operator|(_bz_ArrayExpr<P_expr1> d1, | | operator|(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseOr<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_nu
mtype> > | | BitwiseOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> | IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> | IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| BitwiseOr<_bz_typename P_expr1::T_numtype, int > > > | | BitwiseOr<typename P_expr1::T_numtype, int > > > | |
| operator|(_bz_ArrayExpr<P_expr1> d1, | | operator|(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| BitwiseOr<_bz_typename P_expr1::T_numtype, int> > | | BitwiseOr<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> | int | | // _bz_ArrayExpr<P_expr1> | int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| BitwiseOr<_bz_typename P_expr1::T_numtype, int > > > | | BitwiseOr<typename P_expr1::T_numtype, int > > > | |
| operator|(_bz_ArrayExpr<P_expr1> d1, | | operator|(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| BitwiseOr<_bz_typename P_expr1::T_numtype, int> > | | BitwiseOr<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> | Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> | Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseOr<int, T_numtype2 > > > | | BitwiseOr<int, T_numtype2 > > > | |
| operator|(IndexPlaceholder<N_index1> d1, | | operator|(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseOr<int, T_numtype2> > | | BitwiseOr<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> | _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> | _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseOr<int, _bz_typename P_expr2::T_numtype > > > | | BitwiseOr<int, typename P_expr2::T_numtype > > > | |
| operator|(IndexPlaceholder<N_index1> d1, | | operator|(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseOr<int, _bz_typename P_expr2::T_numtype> > | | BitwiseOr<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> | IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> | IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseOr<int, int > > > | | BitwiseOr<int, int > > > | |
| operator|(IndexPlaceholder<N_index1> d1, | | operator|(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseOr<int, int> > | | BitwiseOr<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> | int | | // IndexPlaceholder<N_index1> | int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseOr<int, int > > > | | BitwiseOr<int, int > > > | |
| operator|(IndexPlaceholder<N_index1> d1, | | operator|(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| BitwiseOr<int, int> > | | BitwiseOr<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // int | Array<T_numtype2, N_rank2> | | // int | Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseOr<int, T_numtype2 > > > | | BitwiseOr<int, T_numtype2 > > > | |
| operator|(int d1, | | operator|(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| BitwiseOr<int, T_numtype2> > | | BitwiseOr<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int | _bz_ArrayExpr<P_expr2> | | // int | _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseOr<int, _bz_typename P_expr2::T_numtype > > > | | BitwiseOr<int, typename P_expr2::T_numtype > > > | |
| operator|(int d1, | | operator|(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| BitwiseOr<int, _bz_typename P_expr2::T_numtype> > | | BitwiseOr<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int | IndexPlaceholder<N_index2> | | // int | IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseOr<int, int > > > | | BitwiseOr<int, int > > > | |
| operator|(int d1, | | operator|(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| BitwiseOr<int, int> > | | BitwiseOr<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Shift right Operators | | * Shift right Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> >> Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> >> Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftRight<T_numtype1, T_numtype2 > > > | | ShiftRight<T_numtype1, T_numtype2 > > > | |
| operator>>(const Array<T_numtype1, N_rank1>& d1, | | operator>>(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftRight<T_numtype1, T_numtype2> > | | ShiftRight<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> >> _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> >> _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftRight<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | ShiftRight<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator>>(const Array<T_numtype1, N_rank1>& d1, | | operator>>(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftRight<T_numtype1, _bz_typename P_expr2::T_numtype> > | | ShiftRight<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> >> IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> >> IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftRight<T_numtype1, int > > > | | ShiftRight<T_numtype1, int > > > | |
| operator>>(const Array<T_numtype1, N_rank1>& d1, | | operator>>(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftRight<T_numtype1, int> > | | ShiftRight<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> >> int | | // Array<T_numtype1, N_rank1> >> int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| ShiftRight<T_numtype1, int > > > | | ShiftRight<T_numtype1, int > > > | |
| operator>>(const Array<T_numtype1, N_rank1>& d1, | | operator>>(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| ShiftRight<T_numtype1, int> > | | ShiftRight<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >> Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> >> Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| ShiftRight<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | ShiftRight<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator>>(_bz_ArrayExpr<P_expr1> d1, | | operator>>(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| ShiftRight<_bz_typename P_expr1::T_numtype, T_numtype2> > | | ShiftRight<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >> _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> >> _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftRight<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_n
umtype > > > | | ShiftRight<typename P_expr1::T_numtype, typename P_expr2::T_numtype >
> > | |
| operator>>(_bz_ArrayExpr<P_expr1> d1, | | operator>>(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftRight<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_n
umtype> > | | ShiftRight<typename P_expr1::T_numtype, typename P_expr2::T_numtype>
> | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >> IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> >> IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| ShiftRight<_bz_typename P_expr1::T_numtype, int > > > | | ShiftRight<typename P_expr1::T_numtype, int > > > | |
| operator>>(_bz_ArrayExpr<P_expr1> d1, | | operator>>(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| ShiftRight<_bz_typename P_expr1::T_numtype, int> > | | ShiftRight<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> >> int | | // _bz_ArrayExpr<P_expr1> >> int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| ShiftRight<_bz_typename P_expr1::T_numtype, int > > > | | ShiftRight<typename P_expr1::T_numtype, int > > > | |
| operator>>(_bz_ArrayExpr<P_expr1> d1, | | operator>>(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| ShiftRight<_bz_typename P_expr1::T_numtype, int> > | | ShiftRight<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> >> Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> >> Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftRight<int, T_numtype2 > > > | | ShiftRight<int, T_numtype2 > > > | |
| operator>>(IndexPlaceholder<N_index1> d1, | | operator>>(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftRight<int, T_numtype2> > | | ShiftRight<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> >> _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> >> _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftRight<int, _bz_typename P_expr2::T_numtype > > > | | ShiftRight<int, typename P_expr2::T_numtype > > > | |
| operator>>(IndexPlaceholder<N_index1> d1, | | operator>>(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftRight<int, _bz_typename P_expr2::T_numtype> > | | ShiftRight<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> >> IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> >> IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftRight<int, int > > > | | ShiftRight<int, int > > > | |
| operator>>(IndexPlaceholder<N_index1> d1, | | operator>>(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftRight<int, int> > | | ShiftRight<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> >> int | | // IndexPlaceholder<N_index1> >> int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| ShiftRight<int, int > > > | | ShiftRight<int, int > > > | |
| operator>>(IndexPlaceholder<N_index1> d1, | | operator>>(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| ShiftRight<int, int> > | | ShiftRight<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // int >> Array<T_numtype2, N_rank2> | | // int >> Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftRight<int, T_numtype2 > > > | | ShiftRight<int, T_numtype2 > > > | |
| operator>>(int d1, | | operator>>(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftRight<int, T_numtype2> > | | ShiftRight<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int >> _bz_ArrayExpr<P_expr2> | | // int >> _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftRight<int, _bz_typename P_expr2::T_numtype > > > | | ShiftRight<int, typename P_expr2::T_numtype > > > | |
| operator>>(int d1, | | operator>>(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftRight<int, _bz_typename P_expr2::T_numtype> > | | ShiftRight<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int >> IndexPlaceholder<N_index2> | | // int >> IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftRight<int, int > > > | | ShiftRight<int, int > > > | |
| operator>>(int d1, | | operator>>(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftRight<int, int> > | | ShiftRight<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Shift left Operators | | * Shift left Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Array<T_numtype1, N_rank1> << Array<T_numtype2, N_rank2> | | // Array<T_numtype1, N_rank1> << Array<T_numtype2, N_rank2> | |
| template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | | template<class T_numtype1, int N_rank1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftLeft<T_numtype1, T_numtype2 > > > | | ShiftLeft<T_numtype1, T_numtype2 > > > | |
| operator<<(const Array<T_numtype1, N_rank1>& d1, | | operator<<(const Array<T_numtype1, N_rank1>& d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftLeft<T_numtype1, T_numtype2> > | | ShiftLeft<T_numtype1, T_numtype2> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> << _bz_ArrayExpr<P_expr2> | | // Array<T_numtype1, N_rank1> << _bz_ArrayExpr<P_expr2> | |
| template<class T_numtype1, int N_rank1, class P_expr2> | | template<class T_numtype1, int N_rank1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftLeft<T_numtype1, _bz_typename P_expr2::T_numtype > > > | | ShiftLeft<T_numtype1, typename P_expr2::T_numtype > > > | |
| operator<<(const Array<T_numtype1, N_rank1>& d1, | | operator<<(const Array<T_numtype1, N_rank1>& d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftLeft<T_numtype1, _bz_typename P_expr2::T_numtype> > | | ShiftLeft<T_numtype1, typename P_expr2::T_numtype> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> << IndexPlaceholder<N_index2> | | // Array<T_numtype1, N_rank1> << IndexPlaceholder<N_index2> | |
| template<class T_numtype1, int N_rank1, int N_index2> | | template<class T_numtype1, int N_rank1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftLeft<T_numtype1, int > > > | | ShiftLeft<T_numtype1, int > > > | |
| operator<<(const Array<T_numtype1, N_rank1>& d1, | | operator<<(const Array<T_numtype1, N_rank1>& d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftLeft<T_numtype1, int> > | | ShiftLeft<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // Array<T_numtype1, N_rank1> << int | | // Array<T_numtype1, N_rank1> << int | |
| template<class T_numtype1, int N_rank1> | | template<class T_numtype1, int N_rank1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| ShiftLeft<T_numtype1, int > > > | | ShiftLeft<T_numtype1, int > > > | |
| operator<<(const Array<T_numtype1, N_rank1>& d1, | | operator<<(const Array<T_numtype1, N_rank1>& d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<ArrayIterator<T_numtype1, N_rank1>, | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| ShiftLeft<T_numtype1, int> > | | ShiftLeft<T_numtype1, int> > | |
| (d1.begin(), | | (d1.begin(), | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> << Array<T_numtype2, N_rank2> | | // _bz_ArrayExpr<P_expr1> << Array<T_numtype2, N_rank2> | |
| template<class P_expr1, class T_numtype2, int N_rank2> | | template<class P_expr1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| ShiftLeft<_bz_typename P_expr1::T_numtype, T_numtype2 > > > | | ShiftLeft<typename P_expr1::T_numtype, T_numtype2 > > > | |
| operator<<(_bz_ArrayExpr<P_expr1> d1, | | operator<<(_bz_ArrayExpr<P_expr1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
|
| ShiftLeft<_bz_typename P_expr1::T_numtype, T_numtype2> > | | ShiftLeft<typename P_expr1::T_numtype, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> << _bz_ArrayExpr<P_expr2> | | // _bz_ArrayExpr<P_expr1> << _bz_ArrayExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftLeft<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_nu
mtype > > > | | ShiftLeft<typename P_expr1::T_numtype, typename P_expr2::T_numtype >
> > | |
| operator<<(_bz_ArrayExpr<P_expr1> d1, | | operator<<(_bz_ArrayExpr<P_expr1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftLeft<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_nu
mtype> > | | ShiftLeft<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> << IndexPlaceholder<N_index2> | | // _bz_ArrayExpr<P_expr1> << IndexPlaceholder<N_index2> | |
| template<class P_expr1, int N_index2> | | template<class P_expr1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| ShiftLeft<_bz_typename P_expr1::T_numtype, int > > > | | ShiftLeft<typename P_expr1::T_numtype, int > > > | |
| operator<<(_bz_ArrayExpr<P_expr1> d1, | | operator<<(_bz_ArrayExpr<P_expr1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
|
| ShiftLeft<_bz_typename P_expr1::T_numtype, int> > | | ShiftLeft<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // _bz_ArrayExpr<P_expr1> << int | | // _bz_ArrayExpr<P_expr1> << int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| ShiftLeft<_bz_typename P_expr1::T_numtype, int > > > | | ShiftLeft<typename P_expr1::T_numtype, int > > > | |
| operator<<(_bz_ArrayExpr<P_expr1> d1, | | operator<<(_bz_ArrayExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExpr<P_expr1>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
|
| ShiftLeft<_bz_typename P_expr1::T_numtype, int> > | | ShiftLeft<typename P_expr1::T_numtype, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> << Array<T_numtype2, N_rank2> | | // IndexPlaceholder<N_index1> << Array<T_numtype2, N_rank2> | |
| template<int N_index1, class T_numtype2, int N_rank2> | | template<int N_index1, class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftLeft<int, T_numtype2 > > > | | ShiftLeft<int, T_numtype2 > > > | |
| operator<<(IndexPlaceholder<N_index1> d1, | | operator<<(IndexPlaceholder<N_index1> d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftLeft<int, T_numtype2> > | | ShiftLeft<int, T_numtype2> > | |
| (d1, | | (d1, | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> << _bz_ArrayExpr<P_expr2> | | // IndexPlaceholder<N_index1> << _bz_ArrayExpr<P_expr2> | |
| template<int N_index1, class P_expr2> | | template<int N_index1, class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftLeft<int, _bz_typename P_expr2::T_numtype > > > | | ShiftLeft<int, typename P_expr2::T_numtype > > > | |
| operator<<(IndexPlaceholder<N_index1> d1, | | operator<<(IndexPlaceholder<N_index1> d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftLeft<int, _bz_typename P_expr2::T_numtype> > | | ShiftLeft<int, typename P_expr2::T_numtype> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> << IndexPlaceholder<N_index2> | | // IndexPlaceholder<N_index1> << IndexPlaceholder<N_index2> | |
| template<int N_index1, int N_index2> | | template<int N_index1, int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftLeft<int, int > > > | | ShiftLeft<int, int > > > | |
| operator<<(IndexPlaceholder<N_index1> d1, | | operator<<(IndexPlaceholder<N_index1> d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftLeft<int, int> > | | ShiftLeft<int, int> > | |
| (d1, | | (d1, | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // IndexPlaceholder<N_index1> << int | | // IndexPlaceholder<N_index1> << int | |
| template<int N_index1> | | template<int N_index1> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| ShiftLeft<int, int > > > | | ShiftLeft<int, int > > > | |
| operator<<(IndexPlaceholder<N_index1> d1, | | operator<<(IndexPlaceholder<N_index1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<IndexPlaceholder<N_index1>, | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| _bz_ArrayExprConstant<int>, | | _bz_ArrayExprConstant<int>, | |
| ShiftLeft<int, int> > | | ShiftLeft<int, int> > | |
| (d1, | | (d1, | |
| _bz_ArrayExprConstant<int>(d2)); | | _bz_ArrayExprConstant<int>(d2)); | |
| } | | } | |
| | | | |
| // int << Array<T_numtype2, N_rank2> | | // int << Array<T_numtype2, N_rank2> | |
| template<class T_numtype2, int N_rank2> | | template<class T_numtype2, int N_rank2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftLeft<int, T_numtype2 > > > | | ShiftLeft<int, T_numtype2 > > > | |
| operator<<(int d1, | | operator<<(int d1, | |
| const Array<T_numtype2, N_rank2>& d2) | | const Array<T_numtype2, N_rank2>& d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| ArrayIterator<T_numtype2, N_rank2>, | | ArrayIterator<T_numtype2, N_rank2>, | |
| ShiftLeft<int, T_numtype2> > | | ShiftLeft<int, T_numtype2> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2.begin()); | | d2.begin()); | |
| } | | } | |
| | | | |
| // int << _bz_ArrayExpr<P_expr2> | | // int << _bz_ArrayExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftLeft<int, _bz_typename P_expr2::T_numtype > > > | | ShiftLeft<int, typename P_expr2::T_numtype > > > | |
| operator<<(int d1, | | operator<<(int d1, | |
| _bz_ArrayExpr<P_expr2> d2) | | _bz_ArrayExpr<P_expr2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| _bz_ArrayExpr<P_expr2>, | | _bz_ArrayExpr<P_expr2>, | |
|
| ShiftLeft<int, _bz_typename P_expr2::T_numtype> > | | ShiftLeft<int, typename P_expr2::T_numtype> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
| | | | |
| // int << IndexPlaceholder<N_index2> | | // int << IndexPlaceholder<N_index2> | |
| template<int N_index2> | | template<int N_index2> | |
| inline | | inline | |
|
| _bz_ArrayExpr<_bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftLeft<int, int > > > | | ShiftLeft<int, int > > > | |
| operator<<(int d1, | | operator<<(int d1, | |
| IndexPlaceholder<N_index2> d2) | | IndexPlaceholder<N_index2> d2) | |
| { | | { | |
|
| return _bz_ArrayExprOp<_bz_ArrayExprConstant<int>, | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| IndexPlaceholder<N_index2>, | | IndexPlaceholder<N_index2>, | |
| ShiftLeft<int, int> > | | ShiftLeft<int, int> > | |
| (_bz_ArrayExprConstant<int>(d1), | | (_bz_ArrayExprConstant<int>(d1), | |
| d2); | | d2); | |
| } | | } | |
|
| | | /************************************************************************** | |
| | | ** | |
| | | * Minimum Operators | |
| | | ************************************************************************** | |
| | | **/ | |
| | | | |
| | | // Array<T_numtype1, N_rank1> min 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>, | |
| | | _bz_Min<T_numtype1, T_numtype2 > > > | |
| | | min(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>, | |
| | | _bz_Min<T_numtype1, T_numtype2> > | |
| | | (d1.begin(), | |
| | | d2.begin()); | |
| | | } | |
| | | | |
| | | // Array<T_numtype1, N_rank1> min _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>, | |
| | | _bz_Min<T_numtype1, typename P_expr2::T_numtype > > > | |
| | | min(const Array<T_numtype1, N_rank1>& d1, | |
| | | _bz_ArrayExpr<P_expr2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Min<T_numtype1, typename P_expr2::T_numtype> > | |
| | | (d1.begin(), | |
| | | d2); | |
| | | } | |
| | | | |
| | | // Array<T_numtype1, N_rank1> min 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>, | |
| | | _bz_Min<T_numtype1, int > > > | |
| | | min(const Array<T_numtype1, N_rank1>& d1, | |
| | | IndexPlaceholder<N_index2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Min<T_numtype1, int> > | |
| | | (d1.begin(), | |
| | | d2); | |
| | | } | |
| | | | |
| | | // Array<T_numtype1, N_rank1> min int | |
| | | template<class T_numtype1, int N_rank1> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Min<T_numtype1, int > > > | |
| | | min(const Array<T_numtype1, N_rank1>& d1, | |
| | | int d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Min<T_numtype1, int> > | |
| | | (d1.begin(), | |
| | | _bz_ArrayExprConstant<int>(d2)); | |
| | | } | |
| | | | |
| | | // _bz_ArrayExpr<P_expr1> min 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>, | |
| | | _bz_Min<typename P_expr1::T_numtype, T_numtype2 > > > | |
| | | min(_bz_ArrayExpr<P_expr1> d1, | |
| | | const Array<T_numtype2, N_rank2>& d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | ArrayIterator<T_numtype2, N_rank2>, | |
| | | _bz_Min<typename P_expr1::T_numtype, T_numtype2> > | |
| | | (d1, | |
| | | d2.begin()); | |
| | | } | |
| | | | |
| | | // _bz_ArrayExpr<P_expr1> min _bz_ArrayExpr<P_expr2> | |
| | | template<class P_expr1, class P_expr2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Min<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > | |
| | | > | |
| | | min(_bz_ArrayExpr<P_expr1> d1, | |
| | | _bz_ArrayExpr<P_expr2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Min<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| | | (d1, | |
| | | d2); | |
| | | } | |
| | | | |
| | | // _bz_ArrayExpr<P_expr1> min IndexPlaceholder<N_index2> | |
| | | template<class P_expr1, int N_index2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Min<typename P_expr1::T_numtype, int > > > | |
| | | min(_bz_ArrayExpr<P_expr1> d1, | |
| | | IndexPlaceholder<N_index2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Min<typename P_expr1::T_numtype, int> > | |
| | | (d1, | |
| | | d2); | |
| | | } | |
| | | | |
| | | // _bz_ArrayExpr<P_expr1> min int | |
| | | template<class P_expr1> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Min<typename P_expr1::T_numtype, int > > > | |
| | | min(_bz_ArrayExpr<P_expr1> d1, | |
| | | int d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Min<typename P_expr1::T_numtype, int> > | |
| | | (d1, | |
| | | _bz_ArrayExprConstant<int>(d2)); | |
| | | } | |
| | | | |
| | | // IndexPlaceholder<N_index1> min 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>, | |
| | | _bz_Min<int, T_numtype2 > > > | |
| | | min(IndexPlaceholder<N_index1> d1, | |
| | | const Array<T_numtype2, N_rank2>& d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | ArrayIterator<T_numtype2, N_rank2>, | |
| | | _bz_Min<int, T_numtype2> > | |
| | | (d1, | |
| | | d2.begin()); | |
| | | } | |
| | | | |
| | | // IndexPlaceholder<N_index1> min _bz_ArrayExpr<P_expr2> | |
| | | template<int N_index1, class P_expr2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Min<int, typename P_expr2::T_numtype > > > | |
| | | min(IndexPlaceholder<N_index1> d1, | |
| | | _bz_ArrayExpr<P_expr2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Min<int, typename P_expr2::T_numtype> > | |
| | | (d1, | |
| | | d2); | |
| | | } | |
| | | | |
| | | // IndexPlaceholder<N_index1> min IndexPlaceholder<N_index2> | |
| | | template<int N_index1, int N_index2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Min<int, int > > > | |
| | | min(IndexPlaceholder<N_index1> d1, | |
| | | IndexPlaceholder<N_index2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Min<int, int> > | |
| | | (d1, | |
| | | d2); | |
| | | } | |
| | | | |
| | | // IndexPlaceholder<N_index1> min int | |
| | | template<int N_index1> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Min<int, int > > > | |
| | | min(IndexPlaceholder<N_index1> d1, | |
| | | int d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Min<int, int> > | |
| | | (d1, | |
| | | _bz_ArrayExprConstant<int>(d2)); | |
| | | } | |
| | | | |
| | | // int min Array<T_numtype2, N_rank2> | |
| | | template<class T_numtype2, int N_rank2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | ArrayIterator<T_numtype2, N_rank2>, | |
| | | _bz_Min<int, T_numtype2 > > > | |
| | | min(int d1, | |
| | | const Array<T_numtype2, N_rank2>& d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | ArrayIterator<T_numtype2, N_rank2>, | |
| | | _bz_Min<int, T_numtype2> > | |
| | | (_bz_ArrayExprConstant<int>(d1), | |
| | | d2.begin()); | |
| | | } | |
| | | | |
| | | // int min _bz_ArrayExpr<P_expr2> | |
| | | template<class P_expr2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Min<int, typename P_expr2::T_numtype > > > | |
| | | min(int d1, | |
| | | _bz_ArrayExpr<P_expr2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Min<int, typename P_expr2::T_numtype> > | |
| | | (_bz_ArrayExprConstant<int>(d1), | |
| | | d2); | |
| | | } | |
| | | | |
| | | // int min IndexPlaceholder<N_index2> | |
| | | template<int N_index2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Min<int, int > > > | |
| | | min(int d1, | |
| | | IndexPlaceholder<N_index2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Min<int, int> > | |
| | | (_bz_ArrayExprConstant<int>(d1), | |
| | | d2); | |
| | | } | |
| | | /************************************************************************** | |
| | | ** | |
| | | * Maximum Operators | |
| | | ************************************************************************** | |
| | | **/ | |
| | | | |
| | | // Array<T_numtype1, N_rank1> max 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>, | |
| | | _bz_Max<T_numtype1, T_numtype2 > > > | |
| | | max(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>, | |
| | | _bz_Max<T_numtype1, T_numtype2> > | |
| | | (d1.begin(), | |
| | | d2.begin()); | |
| | | } | |
| | | | |
| | | // Array<T_numtype1, N_rank1> max _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>, | |
| | | _bz_Max<T_numtype1, typename P_expr2::T_numtype > > > | |
| | | max(const Array<T_numtype1, N_rank1>& d1, | |
| | | _bz_ArrayExpr<P_expr2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Max<T_numtype1, typename P_expr2::T_numtype> > | |
| | | (d1.begin(), | |
| | | d2); | |
| | | } | |
| | | | |
| | | // Array<T_numtype1, N_rank1> max 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>, | |
| | | _bz_Max<T_numtype1, int > > > | |
| | | max(const Array<T_numtype1, N_rank1>& d1, | |
| | | IndexPlaceholder<N_index2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Max<T_numtype1, int> > | |
| | | (d1.begin(), | |
| | | d2); | |
| | | } | |
| | | | |
| | | // Array<T_numtype1, N_rank1> max int | |
| | | template<class T_numtype1, int N_rank1> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Max<T_numtype1, int > > > | |
| | | max(const Array<T_numtype1, N_rank1>& d1, | |
| | | int d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<ArrayIterator<T_numtype1, N_rank1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Max<T_numtype1, int> > | |
| | | (d1.begin(), | |
| | | _bz_ArrayExprConstant<int>(d2)); | |
| | | } | |
| | | | |
| | | // _bz_ArrayExpr<P_expr1> max 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>, | |
| | | _bz_Max<typename P_expr1::T_numtype, T_numtype2 > > > | |
| | | max(_bz_ArrayExpr<P_expr1> d1, | |
| | | const Array<T_numtype2, N_rank2>& d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | ArrayIterator<T_numtype2, N_rank2>, | |
| | | _bz_Max<typename P_expr1::T_numtype, T_numtype2> > | |
| | | (d1, | |
| | | d2.begin()); | |
| | | } | |
| | | | |
| | | // _bz_ArrayExpr<P_expr1> max _bz_ArrayExpr<P_expr2> | |
| | | template<class P_expr1, class P_expr2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Max<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > | |
| | | > | |
| | | max(_bz_ArrayExpr<P_expr1> d1, | |
| | | _bz_ArrayExpr<P_expr2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Max<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > | |
| | | (d1, | |
| | | d2); | |
| | | } | |
| | | | |
| | | // _bz_ArrayExpr<P_expr1> max IndexPlaceholder<N_index2> | |
| | | template<class P_expr1, int N_index2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Max<typename P_expr1::T_numtype, int > > > | |
| | | max(_bz_ArrayExpr<P_expr1> d1, | |
| | | IndexPlaceholder<N_index2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Max<typename P_expr1::T_numtype, int> > | |
| | | (d1, | |
| | | d2); | |
| | | } | |
| | | | |
| | | // _bz_ArrayExpr<P_expr1> max int | |
| | | template<class P_expr1> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Max<typename P_expr1::T_numtype, int > > > | |
| | | max(_bz_ArrayExpr<P_expr1> d1, | |
| | | int d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExpr<P_expr1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Max<typename P_expr1::T_numtype, int> > | |
| | | (d1, | |
| | | _bz_ArrayExprConstant<int>(d2)); | |
| | | } | |
| | | | |
| | | // IndexPlaceholder<N_index1> max 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>, | |
| | | _bz_Max<int, T_numtype2 > > > | |
| | | max(IndexPlaceholder<N_index1> d1, | |
| | | const Array<T_numtype2, N_rank2>& d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | ArrayIterator<T_numtype2, N_rank2>, | |
| | | _bz_Max<int, T_numtype2> > | |
| | | (d1, | |
| | | d2.begin()); | |
| | | } | |
| | | | |
| | | // IndexPlaceholder<N_index1> max _bz_ArrayExpr<P_expr2> | |
| | | template<int N_index1, class P_expr2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Max<int, typename P_expr2::T_numtype > > > | |
| | | max(IndexPlaceholder<N_index1> d1, | |
| | | _bz_ArrayExpr<P_expr2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Max<int, typename P_expr2::T_numtype> > | |
| | | (d1, | |
| | | d2); | |
| | | } | |
| | | | |
| | | // IndexPlaceholder<N_index1> max IndexPlaceholder<N_index2> | |
| | | template<int N_index1, int N_index2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Max<int, int > > > | |
| | | max(IndexPlaceholder<N_index1> d1, | |
| | | IndexPlaceholder<N_index2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Max<int, int> > | |
| | | (d1, | |
| | | d2); | |
| | | } | |
| | | | |
| | | // IndexPlaceholder<N_index1> max int | |
| | | template<int N_index1> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Max<int, int > > > | |
| | | max(IndexPlaceholder<N_index1> d1, | |
| | | int d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<IndexPlaceholder<N_index1>, | |
| | | _bz_ArrayExprConstant<int>, | |
| | | _bz_Max<int, int> > | |
| | | (d1, | |
| | | _bz_ArrayExprConstant<int>(d2)); | |
| | | } | |
| | | | |
| | | // int max Array<T_numtype2, N_rank2> | |
| | | template<class T_numtype2, int N_rank2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | ArrayIterator<T_numtype2, N_rank2>, | |
| | | _bz_Max<int, T_numtype2 > > > | |
| | | max(int d1, | |
| | | const Array<T_numtype2, N_rank2>& d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | ArrayIterator<T_numtype2, N_rank2>, | |
| | | _bz_Max<int, T_numtype2> > | |
| | | (_bz_ArrayExprConstant<int>(d1), | |
| | | d2.begin()); | |
| | | } | |
| | | | |
| | | // int max _bz_ArrayExpr<P_expr2> | |
| | | template<class P_expr2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Max<int, typename P_expr2::T_numtype > > > | |
| | | max(int d1, | |
| | | _bz_ArrayExpr<P_expr2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | _bz_ArrayExpr<P_expr2>, | |
| | | _bz_Max<int, typename P_expr2::T_numtype> > | |
| | | (_bz_ArrayExprConstant<int>(d1), | |
| | | d2); | |
| | | } | |
| | | | |
| | | // int max IndexPlaceholder<N_index2> | |
| | | template<int N_index2> | |
| | | inline | |
| | | _bz_ArrayExpr<_bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Max<int, int > > > | |
| | | max(int d1, | |
| | | IndexPlaceholder<N_index2> d2) | |
| | | { | |
| | | return _bz_ArrayExprBinaryOp<_bz_ArrayExprConstant<int>, | |
| | | IndexPlaceholder<N_index2>, | |
| | | _bz_Max<int, int> > | |
| | | (_bz_ArrayExprConstant<int>(d1), | |
| | | d2); | |
| | | } | |
| BZ_NAMESPACE_END | | BZ_NAMESPACE_END | |
| | | | |
| #endif | | #endif | |
| | | | |
End of changes. 1441 change blocks. |
| 1448 lines changed or deleted | | 1938 lines changed or added | |
|
| matbops.h | | matbops.h | |
| // Generated source file. Do not edit. | | // Generated source file. Do not edit. | |
|
| // Created by: genmatbops.cpp Jun 28 2002 15:25:04 | | // Created by: genmatbops.cpp Dec 10 2003 17:58:20 | |
| | | | |
| #ifndef BZ_MATBOPS_H | | #ifndef BZ_MATBOPS_H | |
| #define BZ_MATBOPS_H | | #define BZ_MATBOPS_H | |
| | | | |
| BZ_NAMESPACE(blitz) | | BZ_NAMESPACE(blitz) | |
| | | | |
| #ifndef BZ_MATEXPR_H | | #ifndef BZ_MATEXPR_H | |
| #error <blitz/matbops.h> must be included via <blitz/matexpr.h> | | #error <blitz/matbops.h> must be included via <blitz/matexpr.h> | |
| #endif | | #endif | |
| | | | |
| | | | |
| skipping to change at line 39 | | skipping to change at line 39 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> + _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> + _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_Add<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator+(const Matrix<P_numtype1, P_struct1>& d1, | | operator+(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Add<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> + int | | // Matrix<P_numtype1, P_struct1> + int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 143 | | skipping to change at line 143 | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> + Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> + Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_Add<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator+(_bz_MatExpr<P_expr1> d1, | | operator+(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_Add<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> + _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> + _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numt
ype > > > | | _bz_Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype > >
> | |
| operator+(_bz_MatExpr<P_expr1> d1, | | operator+(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numt
ype> > T_expr; | | _bz_Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T
_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> + int | | // _bz_MatExpr<P_expr1> + int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, int > > > | | _bz_Add<typename P_expr1::T_numtype, int > > > | |
| operator+(_bz_MatExpr<P_expr1> d1, | | operator+(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_Add<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> + float | | // _bz_MatExpr<P_expr1> + float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, float > > > | | _bz_Add<typename P_expr1::T_numtype, float > > > | |
| operator+(_bz_MatExpr<P_expr1> d1, | | operator+(_bz_MatExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, float> > T_expr; | | _bz_Add<typename P_expr1::T_numtype, float> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<float>(d2))); | | _bz_MatExprConstant<float>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> + double | | // _bz_MatExpr<P_expr1> + double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, double > > > | | _bz_Add<typename P_expr1::T_numtype, double > > > | |
| operator+(_bz_MatExpr<P_expr1> d1, | | operator+(_bz_MatExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, double> > T_expr; | | _bz_Add<typename P_expr1::T_numtype, double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<double>(d2))); | | _bz_MatExprConstant<double>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> + long double | | // _bz_MatExpr<P_expr1> + long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, long double > > > | | _bz_Add<typename P_expr1::T_numtype, long double > > > | |
| operator+(_bz_MatExpr<P_expr1> d1, | | operator+(_bz_MatExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, long double> > T_expr; | | _bz_Add<typename P_expr1::T_numtype, long double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<long double>(d2))); | | _bz_MatExprConstant<long double>(d2))); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> + complex<T2> | | // _bz_MatExpr<P_expr1> + complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | _bz_Add<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator+(_bz_MatExpr<P_expr1> d1, | | operator+(_bz_MatExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Add<_bz_typename P_expr1::T_numtype, complex<T2> > > T_expr; | | _bz_Add<typename P_expr1::T_numtype, complex<T2> > > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int + Matrix<P_numtype2, P_struct2> | | // int + Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 281 | | skipping to change at line 281 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int + _bz_MatExpr<P_expr2> | | // int + _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<int, _bz_typename P_expr2::T_numtype > > > | | _bz_Add<int, typename P_expr2::T_numtype > > > | |
| operator+(int d1, | | operator+(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Add<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // float + Matrix<P_numtype2, P_struct2> | | // float + Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 315 | | skipping to change at line 315 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // float + _bz_MatExpr<P_expr2> | | // float + _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<float, _bz_typename P_expr2::T_numtype > > > | | _bz_Add<float, typename P_expr2::T_numtype > > > | |
| operator+(float d1, | | operator+(float d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<float, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Add<float, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // double + Matrix<P_numtype2, P_struct2> | | // double + Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 349 | | skipping to change at line 349 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // double + _bz_MatExpr<P_expr2> | | // double + _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<double, _bz_typename P_expr2::T_numtype > > > | | _bz_Add<double, typename P_expr2::T_numtype > > > | |
| operator+(double d1, | | operator+(double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Add<double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // long double + Matrix<P_numtype2, P_struct2> | | // long double + Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 383 | | skipping to change at line 383 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // long double + _bz_MatExpr<P_expr2> | | // long double + _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<long double, _bz_typename P_expr2::T_numtype > > > | | _bz_Add<long double, typename P_expr2::T_numtype > > > | |
| operator+(long double d1, | | operator+(long double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<long double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Add<long double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> + Matrix<P_numtype2, P_struct2> | | // complex<T1> + Matrix<P_numtype2, P_struct2> | |
| template<class T1, class P_numtype2, class P_struct2> | | template<class T1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| | | | |
| skipping to change at line 421 | | skipping to change at line 421 | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> + _bz_MatExpr<P_expr2> | | // complex<T1> + _bz_MatExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | _bz_Add<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator+(complex<T1> d1, | | operator+(complex<T1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Add<complex<T1> , _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Add<complex<T1> , typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | |
| d2)); | | d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Subtraction Operators | | * Subtraction Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| | | | |
| skipping to change at line 460 | | skipping to change at line 460 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> - _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> - _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_Subtract<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator-(const Matrix<P_numtype1, P_struct1>& d1, | | operator-(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Subtract<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> - int | | // Matrix<P_numtype1, P_struct1> - int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 564 | | skipping to change at line 564 | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> - Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> - Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_Subtract<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator-(_bz_MatExpr<P_expr1> d1, | | operator-(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_Subtract<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> - _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> - _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T
_numtype > > > | | _bz_Subtract<typename P_expr1::T_numtype, typename P_expr2::T_numtype
> > > | |
| operator-(_bz_MatExpr<P_expr1> d1, | | operator-(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T
_numtype> > T_expr; | | _bz_Subtract<typename P_expr1::T_numtype, typename P_expr2::T_numtype
> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> - int | | // _bz_MatExpr<P_expr1> - int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, int > > > | | _bz_Subtract<typename P_expr1::T_numtype, int > > > | |
| operator-(_bz_MatExpr<P_expr1> d1, | | operator-(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_Subtract<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> - float | | // _bz_MatExpr<P_expr1> - float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, float > > > | | _bz_Subtract<typename P_expr1::T_numtype, float > > > | |
| operator-(_bz_MatExpr<P_expr1> d1, | | operator-(_bz_MatExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, float> > T_expr; | | _bz_Subtract<typename P_expr1::T_numtype, float> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<float>(d2))); | | _bz_MatExprConstant<float>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> - double | | // _bz_MatExpr<P_expr1> - double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, double > > > | | _bz_Subtract<typename P_expr1::T_numtype, double > > > | |
| operator-(_bz_MatExpr<P_expr1> d1, | | operator-(_bz_MatExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, double> > T_expr; | | _bz_Subtract<typename P_expr1::T_numtype, double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<double>(d2))); | | _bz_MatExprConstant<double>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> - long double | | // _bz_MatExpr<P_expr1> - long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, long double > > > | | _bz_Subtract<typename P_expr1::T_numtype, long double > > > | |
| operator-(_bz_MatExpr<P_expr1> d1, | | operator-(_bz_MatExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, long double> > T_expr; | | _bz_Subtract<typename P_expr1::T_numtype, long double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<long double>(d2))); | | _bz_MatExprConstant<long double>(d2))); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> - complex<T2> | | // _bz_MatExpr<P_expr1> - complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | _bz_Subtract<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator-(_bz_MatExpr<P_expr1> d1, | | operator-(_bz_MatExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Subtract<_bz_typename P_expr1::T_numtype, complex<T2> > > T_expr; | | _bz_Subtract<typename P_expr1::T_numtype, complex<T2> > > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int - Matrix<P_numtype2, P_struct2> | | // int - Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 702 | | skipping to change at line 702 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int - _bz_MatExpr<P_expr2> | | // int - _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<int, _bz_typename P_expr2::T_numtype > > > | | _bz_Subtract<int, typename P_expr2::T_numtype > > > | |
| operator-(int d1, | | operator-(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Subtract<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // float - Matrix<P_numtype2, P_struct2> | | // float - Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 736 | | skipping to change at line 736 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // float - _bz_MatExpr<P_expr2> | | // float - _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<float, _bz_typename P_expr2::T_numtype > > > | | _bz_Subtract<float, typename P_expr2::T_numtype > > > | |
| operator-(float d1, | | operator-(float d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<float, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Subtract<float, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // double - Matrix<P_numtype2, P_struct2> | | // double - Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 770 | | skipping to change at line 770 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // double - _bz_MatExpr<P_expr2> | | // double - _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<double, _bz_typename P_expr2::T_numtype > > > | | _bz_Subtract<double, typename P_expr2::T_numtype > > > | |
| operator-(double d1, | | operator-(double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Subtract<double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // long double - Matrix<P_numtype2, P_struct2> | | // long double - Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 804 | | skipping to change at line 804 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // long double - _bz_MatExpr<P_expr2> | | // long double - _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<long double, _bz_typename P_expr2::T_numtype > > > | | _bz_Subtract<long double, typename P_expr2::T_numtype > > > | |
| operator-(long double d1, | | operator-(long double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<long double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Subtract<long double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> - Matrix<P_numtype2, P_struct2> | | // complex<T1> - Matrix<P_numtype2, P_struct2> | |
| template<class T1, class P_numtype2, class P_struct2> | | template<class T1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| | | | |
| skipping to change at line 842 | | skipping to change at line 842 | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> - _bz_MatExpr<P_expr2> | | // complex<T1> - _bz_MatExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | _bz_Subtract<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator-(complex<T1> d1, | | operator-(complex<T1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Subtract<complex<T1> , _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Subtract<complex<T1> , typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | |
| d2)); | | d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Multiplication Operators | | * Multiplication Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| | | | |
| skipping to change at line 881 | | skipping to change at line 881 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> * _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> * _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_Multiply<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator*(const Matrix<P_numtype1, P_struct1>& d1, | | operator*(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Multiply<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> * int | | // Matrix<P_numtype1, P_struct1> * int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 985 | | skipping to change at line 985 | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> * Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> * Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_Multiply<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator*(_bz_MatExpr<P_expr1> d1, | | operator*(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_Multiply<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> * _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> * _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T
_numtype > > > | | _bz_Multiply<typename P_expr1::T_numtype, typename P_expr2::T_numtype
> > > | |
| operator*(_bz_MatExpr<P_expr1> d1, | | operator*(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T
_numtype> > T_expr; | | _bz_Multiply<typename P_expr1::T_numtype, typename P_expr2::T_numtype
> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> * int | | // _bz_MatExpr<P_expr1> * int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, int > > > | | _bz_Multiply<typename P_expr1::T_numtype, int > > > | |
| operator*(_bz_MatExpr<P_expr1> d1, | | operator*(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_Multiply<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> * float | | // _bz_MatExpr<P_expr1> * float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, float > > > | | _bz_Multiply<typename P_expr1::T_numtype, float > > > | |
| operator*(_bz_MatExpr<P_expr1> d1, | | operator*(_bz_MatExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, float> > T_expr; | | _bz_Multiply<typename P_expr1::T_numtype, float> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<float>(d2))); | | _bz_MatExprConstant<float>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> * double | | // _bz_MatExpr<P_expr1> * double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, double > > > | | _bz_Multiply<typename P_expr1::T_numtype, double > > > | |
| operator*(_bz_MatExpr<P_expr1> d1, | | operator*(_bz_MatExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, double> > T_expr; | | _bz_Multiply<typename P_expr1::T_numtype, double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<double>(d2))); | | _bz_MatExprConstant<double>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> * long double | | // _bz_MatExpr<P_expr1> * long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, long double > > > | | _bz_Multiply<typename P_expr1::T_numtype, long double > > > | |
| operator*(_bz_MatExpr<P_expr1> d1, | | operator*(_bz_MatExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, long double> > T_expr; | | _bz_Multiply<typename P_expr1::T_numtype, long double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<long double>(d2))); | | _bz_MatExprConstant<long double>(d2))); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> * complex<T2> | | // _bz_MatExpr<P_expr1> * complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | _bz_Multiply<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator*(_bz_MatExpr<P_expr1> d1, | | operator*(_bz_MatExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Multiply<_bz_typename P_expr1::T_numtype, complex<T2> > > T_expr; | | _bz_Multiply<typename P_expr1::T_numtype, complex<T2> > > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int * Matrix<P_numtype2, P_struct2> | | // int * Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 1123 | | skipping to change at line 1123 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int * _bz_MatExpr<P_expr2> | | // int * _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<int, _bz_typename P_expr2::T_numtype > > > | | _bz_Multiply<int, typename P_expr2::T_numtype > > > | |
| operator*(int d1, | | operator*(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Multiply<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // float * Matrix<P_numtype2, P_struct2> | | // float * Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 1157 | | skipping to change at line 1157 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // float * _bz_MatExpr<P_expr2> | | // float * _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<float, _bz_typename P_expr2::T_numtype > > > | | _bz_Multiply<float, typename P_expr2::T_numtype > > > | |
| operator*(float d1, | | operator*(float d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<float, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Multiply<float, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // double * Matrix<P_numtype2, P_struct2> | | // double * Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 1191 | | skipping to change at line 1191 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // double * _bz_MatExpr<P_expr2> | | // double * _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<double, _bz_typename P_expr2::T_numtype > > > | | _bz_Multiply<double, typename P_expr2::T_numtype > > > | |
| operator*(double d1, | | operator*(double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Multiply<double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // long double * Matrix<P_numtype2, P_struct2> | | // long double * Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 1225 | | skipping to change at line 1225 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // long double * _bz_MatExpr<P_expr2> | | // long double * _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<long double, _bz_typename P_expr2::T_numtype > > > | | _bz_Multiply<long double, typename P_expr2::T_numtype > > > | |
| operator*(long double d1, | | operator*(long double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<long double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Multiply<long double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> * Matrix<P_numtype2, P_struct2> | | // complex<T1> * Matrix<P_numtype2, P_struct2> | |
| template<class T1, class P_numtype2, class P_struct2> | | template<class T1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| | | | |
| skipping to change at line 1263 | | skipping to change at line 1263 | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> * _bz_MatExpr<P_expr2> | | // complex<T1> * _bz_MatExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | _bz_Multiply<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator*(complex<T1> d1, | | operator*(complex<T1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Multiply<complex<T1> , _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Multiply<complex<T1> , typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | |
| d2)); | | d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Division Operators | | * Division Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| | | | |
| skipping to change at line 1302 | | skipping to change at line 1302 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> / _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> / _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_Divide<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator/(const Matrix<P_numtype1, P_struct1>& d1, | | operator/(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Divide<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> / int | | // Matrix<P_numtype1, P_struct1> / int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 1406 | | skipping to change at line 1406 | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> / Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> / Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_Divide<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator/(_bz_MatExpr<P_expr1> d1, | | operator/(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_Divide<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> / _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> / _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_n
umtype > > > | | _bz_Divide<typename P_expr1::T_numtype, typename P_expr2::T_numtype >
> > | |
| operator/(_bz_MatExpr<P_expr1> d1, | | operator/(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_n
umtype> > T_expr; | | _bz_Divide<typename P_expr1::T_numtype, typename P_expr2::T_numtype>
> T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> / int | | // _bz_MatExpr<P_expr1> / int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, int > > > | | _bz_Divide<typename P_expr1::T_numtype, int > > > | |
| operator/(_bz_MatExpr<P_expr1> d1, | | operator/(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_Divide<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> / float | | // _bz_MatExpr<P_expr1> / float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, float > > > | | _bz_Divide<typename P_expr1::T_numtype, float > > > | |
| operator/(_bz_MatExpr<P_expr1> d1, | | operator/(_bz_MatExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, float> > T_expr; | | _bz_Divide<typename P_expr1::T_numtype, float> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<float>(d2))); | | _bz_MatExprConstant<float>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> / double | | // _bz_MatExpr<P_expr1> / double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, double > > > | | _bz_Divide<typename P_expr1::T_numtype, double > > > | |
| operator/(_bz_MatExpr<P_expr1> d1, | | operator/(_bz_MatExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, double> > T_expr; | | _bz_Divide<typename P_expr1::T_numtype, double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<double>(d2))); | | _bz_MatExprConstant<double>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> / long double | | // _bz_MatExpr<P_expr1> / long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, long double > > > | | _bz_Divide<typename P_expr1::T_numtype, long double > > > | |
| operator/(_bz_MatExpr<P_expr1> d1, | | operator/(_bz_MatExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, long double> > T_expr; | | _bz_Divide<typename P_expr1::T_numtype, long double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<long double>(d2))); | | _bz_MatExprConstant<long double>(d2))); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> / complex<T2> | | // _bz_MatExpr<P_expr1> / complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | _bz_Divide<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator/(_bz_MatExpr<P_expr1> d1, | | operator/(_bz_MatExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Divide<_bz_typename P_expr1::T_numtype, complex<T2> > > T_expr; | | _bz_Divide<typename P_expr1::T_numtype, complex<T2> > > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int / Matrix<P_numtype2, P_struct2> | | // int / Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 1544 | | skipping to change at line 1544 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int / _bz_MatExpr<P_expr2> | | // int / _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<int, _bz_typename P_expr2::T_numtype > > > | | _bz_Divide<int, typename P_expr2::T_numtype > > > | |
| operator/(int d1, | | operator/(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Divide<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // float / Matrix<P_numtype2, P_struct2> | | // float / Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 1578 | | skipping to change at line 1578 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // float / _bz_MatExpr<P_expr2> | | // float / _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<float, _bz_typename P_expr2::T_numtype > > > | | _bz_Divide<float, typename P_expr2::T_numtype > > > | |
| operator/(float d1, | | operator/(float d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<float, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Divide<float, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // double / Matrix<P_numtype2, P_struct2> | | // double / Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 1612 | | skipping to change at line 1612 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // double / _bz_MatExpr<P_expr2> | | // double / _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<double, _bz_typename P_expr2::T_numtype > > > | | _bz_Divide<double, typename P_expr2::T_numtype > > > | |
| operator/(double d1, | | operator/(double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Divide<double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // long double / Matrix<P_numtype2, P_struct2> | | // long double / Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 1646 | | skipping to change at line 1646 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // long double / _bz_MatExpr<P_expr2> | | // long double / _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<long double, _bz_typename P_expr2::T_numtype > > > | | _bz_Divide<long double, typename P_expr2::T_numtype > > > | |
| operator/(long double d1, | | operator/(long double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<long double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Divide<long double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> / Matrix<P_numtype2, P_struct2> | | // complex<T1> / Matrix<P_numtype2, P_struct2> | |
| template<class T1, class P_numtype2, class P_struct2> | | template<class T1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| | | | |
| skipping to change at line 1684 | | skipping to change at line 1684 | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> / _bz_MatExpr<P_expr2> | | // complex<T1> / _bz_MatExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | _bz_Divide<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator/(complex<T1> d1, | | operator/(complex<T1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Divide<complex<T1> , _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Divide<complex<T1> , typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | |
| d2)); | | d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Modulus Operators | | * Modulus Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| | | | |
| skipping to change at line 1723 | | skipping to change at line 1723 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> % _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> % _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Mod<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_Mod<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator%(const Matrix<P_numtype1, P_struct1>& d1, | | operator%(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Mod<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Mod<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> % int | | // Matrix<P_numtype1, P_struct1> % int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 1757 | | skipping to change at line 1757 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> % Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> % Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Mod<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_Mod<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator%(_bz_MatExpr<P_expr1> d1, | | operator%(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Mod<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_Mod<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> % _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> % _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Mod<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numt
ype > > > | | _bz_Mod<typename P_expr1::T_numtype, typename P_expr2::T_numtype > >
> | |
| operator%(_bz_MatExpr<P_expr1> d1, | | operator%(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Mod<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_numt
ype> > T_expr; | | _bz_Mod<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T
_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> % int | | // _bz_MatExpr<P_expr1> % int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Mod<_bz_typename P_expr1::T_numtype, int > > > | | _bz_Mod<typename P_expr1::T_numtype, int > > > | |
| operator%(_bz_MatExpr<P_expr1> d1, | | operator%(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Mod<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_Mod<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // int % Matrix<P_numtype2, P_struct2> | | // int % Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 1825 | | skipping to change at line 1825 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int % _bz_MatExpr<P_expr2> | | // int % _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Mod<int, _bz_typename P_expr2::T_numtype > > > | | _bz_Mod<int, typename P_expr2::T_numtype > > > | |
| operator%(int d1, | | operator%(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Mod<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Mod<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Bitwise XOR Operators | | * Bitwise XOR Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Matrix<P_numtype1, P_struct1> ^ Matrix<P_numtype2, P_struct2> | | // Matrix<P_numtype1, P_struct1> ^ Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | | template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | |
| | | | |
| skipping to change at line 1862 | | skipping to change at line 1862 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> ^ _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> ^ _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseXOR<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator^(const Matrix<P_numtype1, P_struct1>& d1, | | operator^(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseXOR<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> ^ int | | // Matrix<P_numtype1, P_struct1> ^ int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 1896 | | skipping to change at line 1896 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> ^ Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> ^ Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_BitwiseXOR<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator^(_bz_MatExpr<P_expr1> d1, | | operator^(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_BitwiseXOR<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> ^ _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> ^ _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseXOR<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2:
:T_numtype > > > | | _bz_BitwiseXOR<typename P_expr1::T_numtype, typename P_expr2::T_numty
pe > > > | |
| operator^(_bz_MatExpr<P_expr1> d1, | | operator^(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseXOR<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2:
:T_numtype> > T_expr; | | _bz_BitwiseXOR<typename P_expr1::T_numtype, typename P_expr2::T_numty
pe> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> ^ int | | // _bz_MatExpr<P_expr1> ^ int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_BitwiseXOR<_bz_typename P_expr1::T_numtype, int > > > | | _bz_BitwiseXOR<typename P_expr1::T_numtype, int > > > | |
| operator^(_bz_MatExpr<P_expr1> d1, | | operator^(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_BitwiseXOR<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_BitwiseXOR<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // int ^ Matrix<P_numtype2, P_struct2> | | // int ^ Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 1964 | | skipping to change at line 1964 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int ^ _bz_MatExpr<P_expr2> | | // int ^ _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseXOR<int, _bz_typename P_expr2::T_numtype > > > | | _bz_BitwiseXOR<int, typename P_expr2::T_numtype > > > | |
| operator^(int d1, | | operator^(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseXOR<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_BitwiseXOR<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Bitwise And Operators | | * Bitwise And Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Matrix<P_numtype1, P_struct1> & Matrix<P_numtype2, P_struct2> | | // Matrix<P_numtype1, P_struct1> & Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | | template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | |
| | | | |
| skipping to change at line 2001 | | skipping to change at line 2001 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> & _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> & _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseAnd<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator&(const Matrix<P_numtype1, P_struct1>& d1, | | operator&(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseAnd<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> & int | | // Matrix<P_numtype1, P_struct1> & int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 2035 | | skipping to change at line 2035 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> & Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> & Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_BitwiseAnd<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator&(_bz_MatExpr<P_expr1> d1, | | operator&(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_BitwiseAnd<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> & _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> & _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseAnd<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2:
:T_numtype > > > | | _bz_BitwiseAnd<typename P_expr1::T_numtype, typename P_expr2::T_numty
pe > > > | |
| operator&(_bz_MatExpr<P_expr1> d1, | | operator&(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseAnd<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2:
:T_numtype> > T_expr; | | _bz_BitwiseAnd<typename P_expr1::T_numtype, typename P_expr2::T_numty
pe> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> & int | | // _bz_MatExpr<P_expr1> & int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_BitwiseAnd<_bz_typename P_expr1::T_numtype, int > > > | | _bz_BitwiseAnd<typename P_expr1::T_numtype, int > > > | |
| operator&(_bz_MatExpr<P_expr1> d1, | | operator&(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_BitwiseAnd<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_BitwiseAnd<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // int & Matrix<P_numtype2, P_struct2> | | // int & Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 2103 | | skipping to change at line 2103 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int & _bz_MatExpr<P_expr2> | | // int & _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseAnd<int, _bz_typename P_expr2::T_numtype > > > | | _bz_BitwiseAnd<int, typename P_expr2::T_numtype > > > | |
| operator&(int d1, | | operator&(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseAnd<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_BitwiseAnd<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Bitwise Or Operators | | * Bitwise Or Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Matrix<P_numtype1, P_struct1> | Matrix<P_numtype2, P_struct2> | | // Matrix<P_numtype1, P_struct1> | Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | | template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | |
| | | | |
| skipping to change at line 2140 | | skipping to change at line 2140 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> | _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> | _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseOr<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator|(const Matrix<P_numtype1, P_struct1>& d1, | | operator|(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseOr<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> | int | | // Matrix<P_numtype1, P_struct1> | int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 2174 | | skipping to change at line 2174 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> | Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> | Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_BitwiseOr<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator|(_bz_MatExpr<P_expr1> d1, | | operator|(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_BitwiseOr<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> | _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> | _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseOr<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::
T_numtype > > > | | _bz_BitwiseOr<typename P_expr1::T_numtype, typename P_expr2::T_numtyp
e > > > | |
| operator|(_bz_MatExpr<P_expr1> d1, | | operator|(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseOr<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::
T_numtype> > T_expr; | | _bz_BitwiseOr<typename P_expr1::T_numtype, typename P_expr2::T_numtyp
e> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> | int | | // _bz_MatExpr<P_expr1> | int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_BitwiseOr<_bz_typename P_expr1::T_numtype, int > > > | | _bz_BitwiseOr<typename P_expr1::T_numtype, int > > > | |
| operator|(_bz_MatExpr<P_expr1> d1, | | operator|(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_BitwiseOr<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_BitwiseOr<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // int | Matrix<P_numtype2, P_struct2> | | // int | Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 2242 | | skipping to change at line 2242 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int | _bz_MatExpr<P_expr2> | | // int | _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseOr<int, _bz_typename P_expr2::T_numtype > > > | | _bz_BitwiseOr<int, typename P_expr2::T_numtype > > > | |
| operator|(int d1, | | operator|(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_BitwiseOr<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_BitwiseOr<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Shift right Operators | | * Shift right Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Matrix<P_numtype1, P_struct1> >> Matrix<P_numtype2, P_struct2> | | // Matrix<P_numtype1, P_struct1> >> Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | | template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | |
| | | | |
| skipping to change at line 2279 | | skipping to change at line 2279 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> >> _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> >> _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftRight<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator>>(const Matrix<P_numtype1, P_struct1>& d1, | | operator>>(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftRight<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> >> int | | // Matrix<P_numtype1, P_struct1> >> int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 2313 | | skipping to change at line 2313 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> >> Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> >> Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_ShiftRight<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator>>(_bz_MatExpr<P_expr1> d1, | | operator>>(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_ShiftRight<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> >> _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> >> _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftRight<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2:
:T_numtype > > > | | _bz_ShiftRight<typename P_expr1::T_numtype, typename P_expr2::T_numty
pe > > > | |
| operator>>(_bz_MatExpr<P_expr1> d1, | | operator>>(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftRight<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2:
:T_numtype> > T_expr; | | _bz_ShiftRight<typename P_expr1::T_numtype, typename P_expr2::T_numty
pe> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> >> int | | // _bz_MatExpr<P_expr1> >> int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_ShiftRight<_bz_typename P_expr1::T_numtype, int > > > | | _bz_ShiftRight<typename P_expr1::T_numtype, int > > > | |
| operator>>(_bz_MatExpr<P_expr1> d1, | | operator>>(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_ShiftRight<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_ShiftRight<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // int >> Matrix<P_numtype2, P_struct2> | | // int >> Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 2381 | | skipping to change at line 2381 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int >> _bz_MatExpr<P_expr2> | | // int >> _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftRight<int, _bz_typename P_expr2::T_numtype > > > | | _bz_ShiftRight<int, typename P_expr2::T_numtype > > > | |
| operator>>(int d1, | | operator>>(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftRight<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_ShiftRight<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Shift left Operators | | * Shift left Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Matrix<P_numtype1, P_struct1> << Matrix<P_numtype2, P_struct2> | | // Matrix<P_numtype1, P_struct1> << Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | | template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | |
| | | | |
| skipping to change at line 2418 | | skipping to change at line 2418 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> << _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> << _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftLeft<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator<<(const Matrix<P_numtype1, P_struct1>& d1, | | operator<<(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftLeft<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> << int | | // Matrix<P_numtype1, P_struct1> << int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 2452 | | skipping to change at line 2452 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> << Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> << Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_ShiftLeft<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator<<(_bz_MatExpr<P_expr1> d1, | | operator<<(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_ShiftLeft<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> << _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> << _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftLeft<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::
T_numtype > > > | | _bz_ShiftLeft<typename P_expr1::T_numtype, typename P_expr2::T_numtyp
e > > > | |
| operator<<(_bz_MatExpr<P_expr1> d1, | | operator<<(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftLeft<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::
T_numtype> > T_expr; | | _bz_ShiftLeft<typename P_expr1::T_numtype, typename P_expr2::T_numtyp
e> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> << int | | // _bz_MatExpr<P_expr1> << int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_ShiftLeft<_bz_typename P_expr1::T_numtype, int > > > | | _bz_ShiftLeft<typename P_expr1::T_numtype, int > > > | |
| operator<<(_bz_MatExpr<P_expr1> d1, | | operator<<(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_ShiftLeft<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_ShiftLeft<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // int << Matrix<P_numtype2, P_struct2> | | // int << Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 2520 | | skipping to change at line 2520 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int << _bz_MatExpr<P_expr2> | | // int << _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftLeft<int, _bz_typename P_expr2::T_numtype > > > | | _bz_ShiftLeft<int, typename P_expr2::T_numtype > > > | |
| operator<<(int d1, | | operator<<(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_ShiftLeft<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_ShiftLeft<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Greater-than Operators | | * Greater-than Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Matrix<P_numtype1, P_struct1> > Matrix<P_numtype2, P_struct2> | | // Matrix<P_numtype1, P_struct1> > Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | | template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | |
| | | | |
| skipping to change at line 2557 | | skipping to change at line 2557 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> > _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> > _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_Greater<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator>(const Matrix<P_numtype1, P_struct1>& d1, | | operator>(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Greater<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> > int | | // Matrix<P_numtype1, P_struct1> > int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 2661 | | skipping to change at line 2661 | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> > Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> > Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_Greater<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator>(_bz_MatExpr<P_expr1> d1, | | operator>(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_Greater<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> > _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> > _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_
numtype > > > | | _bz_Greater<typename P_expr1::T_numtype, typename P_expr2::T_numtype
> > > | |
| operator>(_bz_MatExpr<P_expr1> d1, | | operator>(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_
numtype> > T_expr; | | _bz_Greater<typename P_expr1::T_numtype, typename P_expr2::T_numtype>
> T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> > int | | // _bz_MatExpr<P_expr1> > int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, int > > > | | _bz_Greater<typename P_expr1::T_numtype, int > > > | |
| operator>(_bz_MatExpr<P_expr1> d1, | | operator>(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_Greater<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> > float | | // _bz_MatExpr<P_expr1> > float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, float > > > | | _bz_Greater<typename P_expr1::T_numtype, float > > > | |
| operator>(_bz_MatExpr<P_expr1> d1, | | operator>(_bz_MatExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, float> > T_expr; | | _bz_Greater<typename P_expr1::T_numtype, float> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<float>(d2))); | | _bz_MatExprConstant<float>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> > double | | // _bz_MatExpr<P_expr1> > double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, double > > > | | _bz_Greater<typename P_expr1::T_numtype, double > > > | |
| operator>(_bz_MatExpr<P_expr1> d1, | | operator>(_bz_MatExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, double> > T_expr; | | _bz_Greater<typename P_expr1::T_numtype, double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<double>(d2))); | | _bz_MatExprConstant<double>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> > long double | | // _bz_MatExpr<P_expr1> > long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, long double > > > | | _bz_Greater<typename P_expr1::T_numtype, long double > > > | |
| operator>(_bz_MatExpr<P_expr1> d1, | | operator>(_bz_MatExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, long double> > T_expr; | | _bz_Greater<typename P_expr1::T_numtype, long double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<long double>(d2))); | | _bz_MatExprConstant<long double>(d2))); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> > complex<T2> | | // _bz_MatExpr<P_expr1> > complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | _bz_Greater<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator>(_bz_MatExpr<P_expr1> d1, | | operator>(_bz_MatExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Greater<_bz_typename P_expr1::T_numtype, complex<T2> > > T_expr; | | _bz_Greater<typename P_expr1::T_numtype, complex<T2> > > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int > Matrix<P_numtype2, P_struct2> | | // int > Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 2799 | | skipping to change at line 2799 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int > _bz_MatExpr<P_expr2> | | // int > _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<int, _bz_typename P_expr2::T_numtype > > > | | _bz_Greater<int, typename P_expr2::T_numtype > > > | |
| operator>(int d1, | | operator>(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Greater<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // float > Matrix<P_numtype2, P_struct2> | | // float > Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 2833 | | skipping to change at line 2833 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // float > _bz_MatExpr<P_expr2> | | // float > _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<float, _bz_typename P_expr2::T_numtype > > > | | _bz_Greater<float, typename P_expr2::T_numtype > > > | |
| operator>(float d1, | | operator>(float d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<float, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Greater<float, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // double > Matrix<P_numtype2, P_struct2> | | // double > Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 2867 | | skipping to change at line 2867 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // double > _bz_MatExpr<P_expr2> | | // double > _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<double, _bz_typename P_expr2::T_numtype > > > | | _bz_Greater<double, typename P_expr2::T_numtype > > > | |
| operator>(double d1, | | operator>(double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Greater<double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // long double > Matrix<P_numtype2, P_struct2> | | // long double > Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 2901 | | skipping to change at line 2901 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // long double > _bz_MatExpr<P_expr2> | | // long double > _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<long double, _bz_typename P_expr2::T_numtype > > > | | _bz_Greater<long double, typename P_expr2::T_numtype > > > | |
| operator>(long double d1, | | operator>(long double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<long double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Greater<long double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> > Matrix<P_numtype2, P_struct2> | | // complex<T1> > Matrix<P_numtype2, P_struct2> | |
| template<class T1, class P_numtype2, class P_struct2> | | template<class T1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| | | | |
| skipping to change at line 2939 | | skipping to change at line 2939 | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> > _bz_MatExpr<P_expr2> | | // complex<T1> > _bz_MatExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | _bz_Greater<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator>(complex<T1> d1, | | operator>(complex<T1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Greater<complex<T1> , _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Greater<complex<T1> , typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | |
| d2)); | | d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Less-than Operators | | * Less-than Operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| | | | |
| skipping to change at line 2978 | | skipping to change at line 2978 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> < _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> < _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_Less<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator<(const Matrix<P_numtype1, P_struct1>& d1, | | operator<(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Less<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> < int | | // Matrix<P_numtype1, P_struct1> < int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 3082 | | skipping to change at line 3082 | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> < Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> < Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_Less<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator<(_bz_MatExpr<P_expr1> d1, | | operator<(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_Less<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> < _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> < _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_num
type > > > | | _bz_Less<typename P_expr1::T_numtype, typename P_expr2::T_numtype > >
> | |
| operator<(_bz_MatExpr<P_expr1> d1, | | operator<(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_num
type> > T_expr; | | _bz_Less<typename P_expr1::T_numtype, typename P_expr2::T_numtype> >
T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> < int | | // _bz_MatExpr<P_expr1> < int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, int > > > | | _bz_Less<typename P_expr1::T_numtype, int > > > | |
| operator<(_bz_MatExpr<P_expr1> d1, | | operator<(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_Less<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> < float | | // _bz_MatExpr<P_expr1> < float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, float > > > | | _bz_Less<typename P_expr1::T_numtype, float > > > | |
| operator<(_bz_MatExpr<P_expr1> d1, | | operator<(_bz_MatExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, float> > T_expr; | | _bz_Less<typename P_expr1::T_numtype, float> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<float>(d2))); | | _bz_MatExprConstant<float>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> < double | | // _bz_MatExpr<P_expr1> < double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, double > > > | | _bz_Less<typename P_expr1::T_numtype, double > > > | |
| operator<(_bz_MatExpr<P_expr1> d1, | | operator<(_bz_MatExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, double> > T_expr; | | _bz_Less<typename P_expr1::T_numtype, double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<double>(d2))); | | _bz_MatExprConstant<double>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> < long double | | // _bz_MatExpr<P_expr1> < long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, long double > > > | | _bz_Less<typename P_expr1::T_numtype, long double > > > | |
| operator<(_bz_MatExpr<P_expr1> d1, | | operator<(_bz_MatExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, long double> > T_expr; | | _bz_Less<typename P_expr1::T_numtype, long double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<long double>(d2))); | | _bz_MatExprConstant<long double>(d2))); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> < complex<T2> | | // _bz_MatExpr<P_expr1> < complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | _bz_Less<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator<(_bz_MatExpr<P_expr1> d1, | | operator<(_bz_MatExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Less<_bz_typename P_expr1::T_numtype, complex<T2> > > T_expr; | | _bz_Less<typename P_expr1::T_numtype, complex<T2> > > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int < Matrix<P_numtype2, P_struct2> | | // int < Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 3220 | | skipping to change at line 3220 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int < _bz_MatExpr<P_expr2> | | // int < _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<int, _bz_typename P_expr2::T_numtype > > > | | _bz_Less<int, typename P_expr2::T_numtype > > > | |
| operator<(int d1, | | operator<(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Less<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // float < Matrix<P_numtype2, P_struct2> | | // float < Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 3254 | | skipping to change at line 3254 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // float < _bz_MatExpr<P_expr2> | | // float < _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<float, _bz_typename P_expr2::T_numtype > > > | | _bz_Less<float, typename P_expr2::T_numtype > > > | |
| operator<(float d1, | | operator<(float d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<float, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Less<float, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // double < Matrix<P_numtype2, P_struct2> | | // double < Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 3288 | | skipping to change at line 3288 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // double < _bz_MatExpr<P_expr2> | | // double < _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<double, _bz_typename P_expr2::T_numtype > > > | | _bz_Less<double, typename P_expr2::T_numtype > > > | |
| operator<(double d1, | | operator<(double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Less<double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // long double < Matrix<P_numtype2, P_struct2> | | // long double < Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 3322 | | skipping to change at line 3322 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // long double < _bz_MatExpr<P_expr2> | | // long double < _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<long double, _bz_typename P_expr2::T_numtype > > > | | _bz_Less<long double, typename P_expr2::T_numtype > > > | |
| operator<(long double d1, | | operator<(long double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<long double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Less<long double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> < Matrix<P_numtype2, P_struct2> | | // complex<T1> < Matrix<P_numtype2, P_struct2> | |
| template<class T1, class P_numtype2, class P_struct2> | | template<class T1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| | | | |
| skipping to change at line 3360 | | skipping to change at line 3360 | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> < _bz_MatExpr<P_expr2> | | // complex<T1> < _bz_MatExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | _bz_Less<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator<(complex<T1> d1, | | operator<(complex<T1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Less<complex<T1> , _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Less<complex<T1> , typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | |
| d2)); | | d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Greater or equal (>=) operators | | * Greater or equal (>=) operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| | | | |
| skipping to change at line 3399 | | skipping to change at line 3399 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> >= _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> >= _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator>=(const Matrix<P_numtype1, P_struct1>& d1, | | operator>=(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<P_numtype1, _bz_typename P_expr2::T_numtype> > T_e
xpr; | | _bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> >= int | | // Matrix<P_numtype1, P_struct1> >= int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 3503 | | skipping to change at line 3503 | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> >= Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> >= Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator>=(_bz_MatExpr<P_expr1> d1, | | operator>=(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, P_numtype2> > T_e
xpr; | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> >= _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> >= _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_ex
pr2::T_numtype > > > | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_n
umtype > > > | |
| operator>=(_bz_MatExpr<P_expr1> d1, | | operator>=(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_ex
pr2::T_numtype> > T_expr; | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_n
umtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> >= int | | // _bz_MatExpr<P_expr1> >= int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, int > > > | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, int > > > | |
| operator>=(_bz_MatExpr<P_expr1> d1, | | operator>=(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> >= float | | // _bz_MatExpr<P_expr1> >= float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, float > > > | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, float > > > | |
| operator>=(_bz_MatExpr<P_expr1> d1, | | operator>=(_bz_MatExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, float> > T_expr; | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, float> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<float>(d2))); | | _bz_MatExprConstant<float>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> >= double | | // _bz_MatExpr<P_expr1> >= double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, double > > > | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, double > > > | |
| operator>=(_bz_MatExpr<P_expr1> d1, | | operator>=(_bz_MatExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, double> > T_expr; | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<double>(d2))); | | _bz_MatExprConstant<double>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> >= long double | | // _bz_MatExpr<P_expr1> >= long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, long double > > > | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, long double > > > | |
| operator>=(_bz_MatExpr<P_expr1> d1, | | operator>=(_bz_MatExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, long double> > T_
expr; | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, long double> > T_expr
; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<long double>(d2))); | | _bz_MatExprConstant<long double>(d2))); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> >= complex<T2> | | // _bz_MatExpr<P_expr1> >= complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, complex<T2> > >
> | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator>=(_bz_MatExpr<P_expr1> d1, | | operator>=(_bz_MatExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_GreaterOrEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > T
_expr; | | _bz_GreaterOrEqual<typename P_expr1::T_numtype, complex<T2> > > T_exp
r; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int >= Matrix<P_numtype2, P_struct2> | | // int >= Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 3641 | | skipping to change at line 3641 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int >= _bz_MatExpr<P_expr2> | | // int >= _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<int, _bz_typename P_expr2::T_numtype > > > | | _bz_GreaterOrEqual<int, typename P_expr2::T_numtype > > > | |
| operator>=(int d1, | | operator>=(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_GreaterOrEqual<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // float >= Matrix<P_numtype2, P_struct2> | | // float >= Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 3675 | | skipping to change at line 3675 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // float >= _bz_MatExpr<P_expr2> | | // float >= _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<float, _bz_typename P_expr2::T_numtype > > > | | _bz_GreaterOrEqual<float, typename P_expr2::T_numtype > > > | |
| operator>=(float d1, | | operator>=(float d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<float, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_GreaterOrEqual<float, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // double >= Matrix<P_numtype2, P_struct2> | | // double >= Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 3709 | | skipping to change at line 3709 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // double >= _bz_MatExpr<P_expr2> | | // double >= _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<double, _bz_typename P_expr2::T_numtype > > > | | _bz_GreaterOrEqual<double, typename P_expr2::T_numtype > > > | |
| operator>=(double d1, | | operator>=(double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_GreaterOrEqual<double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // long double >= Matrix<P_numtype2, P_struct2> | | // long double >= Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 3743 | | skipping to change at line 3743 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // long double >= _bz_MatExpr<P_expr2> | | // long double >= _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<long double, _bz_typename P_expr2::T_numtype > > > | | _bz_GreaterOrEqual<long double, typename P_expr2::T_numtype > > > | |
| operator>=(long double d1, | | operator>=(long double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<long double, _bz_typename P_expr2::T_numtype> > T_
expr; | | _bz_GreaterOrEqual<long double, typename P_expr2::T_numtype> > T_expr
; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> >= Matrix<P_numtype2, P_struct2> | | // complex<T1> >= Matrix<P_numtype2, P_struct2> | |
| template<class T1, class P_numtype2, class P_struct2> | | template<class T1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| | | | |
| skipping to change at line 3781 | | skipping to change at line 3781 | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> >= _bz_MatExpr<P_expr2> | | // complex<T1> >= _bz_MatExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<complex<T1> , _bz_typename P_expr2::T_numtype > >
> | | _bz_GreaterOrEqual<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator>=(complex<T1> d1, | | operator>=(complex<T1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_GreaterOrEqual<complex<T1> , _bz_typename P_expr2::T_numtype> > T
_expr; | | _bz_GreaterOrEqual<complex<T1> , typename P_expr2::T_numtype> > T_exp
r; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | |
| d2)); | | d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Less or equal (<=) operators | | * Less or equal (<=) operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| | | | |
| skipping to change at line 3820 | | skipping to change at line 3820 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> <= _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> <= _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator<=(const Matrix<P_numtype1, P_struct1>& d1, | | operator<=(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr
; | | _bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> <= int | | // Matrix<P_numtype1, P_struct1> <= int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 3924 | | skipping to change at line 3924 | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> <= Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> <= Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator<=(_bz_MatExpr<P_expr1> d1, | | operator<=(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr
; | | _bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> <= _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> <= _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2
::T_numtype > > > | | _bz_LessOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numt
ype > > > | |
| operator<=(_bz_MatExpr<P_expr1> d1, | | operator<=(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2
::T_numtype> > T_expr; | | _bz_LessOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numt
ype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> <= int | | // _bz_MatExpr<P_expr1> <= int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, int > > > | | _bz_LessOrEqual<typename P_expr1::T_numtype, int > > > | |
| operator<=(_bz_MatExpr<P_expr1> d1, | | operator<=(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_LessOrEqual<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> <= float | | // _bz_MatExpr<P_expr1> <= float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, float > > > | | _bz_LessOrEqual<typename P_expr1::T_numtype, float > > > | |
| operator<=(_bz_MatExpr<P_expr1> d1, | | operator<=(_bz_MatExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, float> > T_expr; | | _bz_LessOrEqual<typename P_expr1::T_numtype, float> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<float>(d2))); | | _bz_MatExprConstant<float>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> <= double | | // _bz_MatExpr<P_expr1> <= double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, double > > > | | _bz_LessOrEqual<typename P_expr1::T_numtype, double > > > | |
| operator<=(_bz_MatExpr<P_expr1> d1, | | operator<=(_bz_MatExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, double> > T_expr; | | _bz_LessOrEqual<typename P_expr1::T_numtype, double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<double>(d2))); | | _bz_MatExprConstant<double>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> <= long double | | // _bz_MatExpr<P_expr1> <= long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, long double > > > | | _bz_LessOrEqual<typename P_expr1::T_numtype, long double > > > | |
| operator<=(_bz_MatExpr<P_expr1> d1, | | operator<=(_bz_MatExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, long double> > T_exp
r; | | _bz_LessOrEqual<typename P_expr1::T_numtype, long double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<long double>(d2))); | | _bz_MatExprConstant<long double>(d2))); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> <= complex<T2> | | // _bz_MatExpr<P_expr1> <= complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | _bz_LessOrEqual<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator<=(_bz_MatExpr<P_expr1> d1, | | operator<=(_bz_MatExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_LessOrEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > T_ex
pr; | | _bz_LessOrEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int <= Matrix<P_numtype2, P_struct2> | | // int <= Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 4062 | | skipping to change at line 4062 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int <= _bz_MatExpr<P_expr2> | | // int <= _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<int, _bz_typename P_expr2::T_numtype > > > | | _bz_LessOrEqual<int, typename P_expr2::T_numtype > > > | |
| operator<=(int d1, | | operator<=(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_LessOrEqual<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // float <= Matrix<P_numtype2, P_struct2> | | // float <= Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 4096 | | skipping to change at line 4096 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // float <= _bz_MatExpr<P_expr2> | | // float <= _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<float, _bz_typename P_expr2::T_numtype > > > | | _bz_LessOrEqual<float, typename P_expr2::T_numtype > > > | |
| operator<=(float d1, | | operator<=(float d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<float, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_LessOrEqual<float, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // double <= Matrix<P_numtype2, P_struct2> | | // double <= Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 4130 | | skipping to change at line 4130 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // double <= _bz_MatExpr<P_expr2> | | // double <= _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<double, _bz_typename P_expr2::T_numtype > > > | | _bz_LessOrEqual<double, typename P_expr2::T_numtype > > > | |
| operator<=(double d1, | | operator<=(double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_LessOrEqual<double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // long double <= Matrix<P_numtype2, P_struct2> | | // long double <= Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 4164 | | skipping to change at line 4164 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // long double <= _bz_MatExpr<P_expr2> | | // long double <= _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<long double, _bz_typename P_expr2::T_numtype > > > | | _bz_LessOrEqual<long double, typename P_expr2::T_numtype > > > | |
| operator<=(long double d1, | | operator<=(long double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<long double, _bz_typename P_expr2::T_numtype> > T_exp
r; | | _bz_LessOrEqual<long double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> <= Matrix<P_numtype2, P_struct2> | | // complex<T1> <= Matrix<P_numtype2, P_struct2> | |
| template<class T1, class P_numtype2, class P_struct2> | | template<class T1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| | | | |
| skipping to change at line 4202 | | skipping to change at line 4202 | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> <= _bz_MatExpr<P_expr2> | | // complex<T1> <= _bz_MatExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | _bz_LessOrEqual<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator<=(complex<T1> d1, | | operator<=(complex<T1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LessOrEqual<complex<T1> , _bz_typename P_expr2::T_numtype> > T_ex
pr; | | _bz_LessOrEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | |
| d2)); | | d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Equality operators | | * Equality operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| | | | |
| skipping to change at line 4241 | | skipping to change at line 4241 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> == _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> == _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_Equal<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator==(const Matrix<P_numtype1, P_struct1>& d1, | | operator==(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Equal<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> == int | | // Matrix<P_numtype1, P_struct1> == int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 4345 | | skipping to change at line 4345 | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> == Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> == Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_Equal<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator==(_bz_MatExpr<P_expr1> d1, | | operator==(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_Equal<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> == _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> == _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_nu
mtype > > > | | _bz_Equal<typename P_expr1::T_numtype, typename P_expr2::T_numtype >
> > | |
| operator==(_bz_MatExpr<P_expr1> d1, | | operator==(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T_nu
mtype> > T_expr; | | _bz_Equal<typename P_expr1::T_numtype, typename P_expr2::T_numtype> >
T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> == int | | // _bz_MatExpr<P_expr1> == int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, int > > > | | _bz_Equal<typename P_expr1::T_numtype, int > > > | |
| operator==(_bz_MatExpr<P_expr1> d1, | | operator==(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_Equal<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> == float | | // _bz_MatExpr<P_expr1> == float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, float > > > | | _bz_Equal<typename P_expr1::T_numtype, float > > > | |
| operator==(_bz_MatExpr<P_expr1> d1, | | operator==(_bz_MatExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, float> > T_expr; | | _bz_Equal<typename P_expr1::T_numtype, float> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<float>(d2))); | | _bz_MatExprConstant<float>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> == double | | // _bz_MatExpr<P_expr1> == double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, double > > > | | _bz_Equal<typename P_expr1::T_numtype, double > > > | |
| operator==(_bz_MatExpr<P_expr1> d1, | | operator==(_bz_MatExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, double> > T_expr; | | _bz_Equal<typename P_expr1::T_numtype, double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<double>(d2))); | | _bz_MatExprConstant<double>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> == long double | | // _bz_MatExpr<P_expr1> == long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, long double > > > | | _bz_Equal<typename P_expr1::T_numtype, long double > > > | |
| operator==(_bz_MatExpr<P_expr1> d1, | | operator==(_bz_MatExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, long double> > T_expr; | | _bz_Equal<typename P_expr1::T_numtype, long double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<long double>(d2))); | | _bz_MatExprConstant<long double>(d2))); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> == complex<T2> | | // _bz_MatExpr<P_expr1> == complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | _bz_Equal<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator==(_bz_MatExpr<P_expr1> d1, | | operator==(_bz_MatExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_Equal<_bz_typename P_expr1::T_numtype, complex<T2> > > T_expr; | | _bz_Equal<typename P_expr1::T_numtype, complex<T2> > > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int == Matrix<P_numtype2, P_struct2> | | // int == Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 4483 | | skipping to change at line 4483 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int == _bz_MatExpr<P_expr2> | | // int == _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<int, _bz_typename P_expr2::T_numtype > > > | | _bz_Equal<int, typename P_expr2::T_numtype > > > | |
| operator==(int d1, | | operator==(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Equal<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // float == Matrix<P_numtype2, P_struct2> | | // float == Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 4517 | | skipping to change at line 4517 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // float == _bz_MatExpr<P_expr2> | | // float == _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<float, _bz_typename P_expr2::T_numtype > > > | | _bz_Equal<float, typename P_expr2::T_numtype > > > | |
| operator==(float d1, | | operator==(float d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<float, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Equal<float, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // double == Matrix<P_numtype2, P_struct2> | | // double == Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 4551 | | skipping to change at line 4551 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // double == _bz_MatExpr<P_expr2> | | // double == _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<double, _bz_typename P_expr2::T_numtype > > > | | _bz_Equal<double, typename P_expr2::T_numtype > > > | |
| operator==(double d1, | | operator==(double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Equal<double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // long double == Matrix<P_numtype2, P_struct2> | | // long double == Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 4585 | | skipping to change at line 4585 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // long double == _bz_MatExpr<P_expr2> | | // long double == _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<long double, _bz_typename P_expr2::T_numtype > > > | | _bz_Equal<long double, typename P_expr2::T_numtype > > > | |
| operator==(long double d1, | | operator==(long double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<long double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Equal<long double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> == Matrix<P_numtype2, P_struct2> | | // complex<T1> == Matrix<P_numtype2, P_struct2> | |
| template<class T1, class P_numtype2, class P_struct2> | | template<class T1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| | | | |
| skipping to change at line 4623 | | skipping to change at line 4623 | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> == _bz_MatExpr<P_expr2> | | // complex<T1> == _bz_MatExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | _bz_Equal<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator==(complex<T1> d1, | | operator==(complex<T1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_Equal<complex<T1> , _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_Equal<complex<T1> , typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | |
| d2)); | | d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Not-equal operators | | * Not-equal operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| | | | |
| skipping to change at line 4662 | | skipping to change at line 4662 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> != _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> != _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_NotEqual<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator!=(const Matrix<P_numtype1, P_struct1>& d1, | | operator!=(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_NotEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> != int | | // Matrix<P_numtype1, P_struct1> != int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 4766 | | skipping to change at line 4766 | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> != Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> != Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_NotEqual<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator!=(_bz_MatExpr<P_expr1> d1, | | operator!=(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_NotEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> != _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> != _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T
_numtype > > > | | _bz_NotEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype
> > > | |
| operator!=(_bz_MatExpr<P_expr1> d1, | | operator!=(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::T
_numtype> > T_expr; | | _bz_NotEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype
> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> != int | | // _bz_MatExpr<P_expr1> != int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, int > > > | | _bz_NotEqual<typename P_expr1::T_numtype, int > > > | |
| operator!=(_bz_MatExpr<P_expr1> d1, | | operator!=(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_NotEqual<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> != float | | // _bz_MatExpr<P_expr1> != float | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, float > > > | | _bz_NotEqual<typename P_expr1::T_numtype, float > > > | |
| operator!=(_bz_MatExpr<P_expr1> d1, | | operator!=(_bz_MatExpr<P_expr1> d1, | |
| float d2) | | float d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<float>, | | _bz_MatExprConstant<float>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, float> > T_expr; | | _bz_NotEqual<typename P_expr1::T_numtype, float> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<float>(d2))); | | _bz_MatExprConstant<float>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> != double | | // _bz_MatExpr<P_expr1> != double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, double > > > | | _bz_NotEqual<typename P_expr1::T_numtype, double > > > | |
| operator!=(_bz_MatExpr<P_expr1> d1, | | operator!=(_bz_MatExpr<P_expr1> d1, | |
| double d2) | | double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<double>, | | _bz_MatExprConstant<double>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, double> > T_expr; | | _bz_NotEqual<typename P_expr1::T_numtype, double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<double>(d2))); | | _bz_MatExprConstant<double>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> != long double | | // _bz_MatExpr<P_expr1> != long double | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, long double > > > | | _bz_NotEqual<typename P_expr1::T_numtype, long double > > > | |
| operator!=(_bz_MatExpr<P_expr1> d1, | | operator!=(_bz_MatExpr<P_expr1> d1, | |
| long double d2) | | long double d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<long double>, | | _bz_MatExprConstant<long double>, | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, long double> > T_expr; | | _bz_NotEqual<typename P_expr1::T_numtype, long double> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<long double>(d2))); | | _bz_MatExprConstant<long double>(d2))); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // _bz_MatExpr<P_expr1> != complex<T2> | | // _bz_MatExpr<P_expr1> != complex<T2> | |
| template<class P_expr1, class T2> | | template<class P_expr1, class T2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > > | | _bz_NotEqual<typename P_expr1::T_numtype, complex<T2> > > > | |
| operator!=(_bz_MatExpr<P_expr1> d1, | | operator!=(_bz_MatExpr<P_expr1> d1, | |
| complex<T2> d2) | | complex<T2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<complex<T2> > , | | _bz_MatExprConstant<complex<T2> > , | |
|
| _bz_NotEqual<_bz_typename P_expr1::T_numtype, complex<T2> > > T_expr; | | _bz_NotEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<complex<T2> > (d2))); | | _bz_MatExprConstant<complex<T2> > (d2))); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| // int != Matrix<P_numtype2, P_struct2> | | // int != Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 4904 | | skipping to change at line 4904 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int != _bz_MatExpr<P_expr2> | | // int != _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<int, _bz_typename P_expr2::T_numtype > > > | | _bz_NotEqual<int, typename P_expr2::T_numtype > > > | |
| operator!=(int d1, | | operator!=(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_NotEqual<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // float != Matrix<P_numtype2, P_struct2> | | // float != Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 4938 | | skipping to change at line 4938 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // float != _bz_MatExpr<P_expr2> | | // float != _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<float, _bz_typename P_expr2::T_numtype > > > | | _bz_NotEqual<float, typename P_expr2::T_numtype > > > | |
| operator!=(float d1, | | operator!=(float d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<float>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<float, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_NotEqual<float, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // double != Matrix<P_numtype2, P_struct2> | | // double != Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 4972 | | skipping to change at line 4972 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // double != _bz_MatExpr<P_expr2> | | // double != _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<double, _bz_typename P_expr2::T_numtype > > > | | _bz_NotEqual<double, typename P_expr2::T_numtype > > > | |
| operator!=(double d1, | | operator!=(double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_NotEqual<double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // long double != Matrix<P_numtype2, P_struct2> | | // long double != Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 5006 | | skipping to change at line 5006 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // long double != _bz_MatExpr<P_expr2> | | // long double != _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<long double, _bz_typename P_expr2::T_numtype > > > | | _bz_NotEqual<long double, typename P_expr2::T_numtype > > > | |
| operator!=(long double d1, | | operator!=(long double d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<long double, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_NotEqual<long double, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> != Matrix<P_numtype2, P_struct2> | | // complex<T1> != Matrix<P_numtype2, P_struct2> | |
| template<class T1, class P_numtype2, class P_struct2> | | template<class T1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| | | | |
| skipping to change at line 5044 | | skipping to change at line 5044 | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| #ifdef BZ_HAVE_COMPLEX | | #ifdef BZ_HAVE_COMPLEX | |
| | | | |
| // complex<T1> != _bz_MatExpr<P_expr2> | | // complex<T1> != _bz_MatExpr<P_expr2> | |
| template<class T1, class P_expr2> | | template<class T1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<complex<T1> , _bz_typename P_expr2::T_numtype > > > | | _bz_NotEqual<complex<T1> , typename P_expr2::T_numtype > > > | |
| operator!=(complex<T1> d1, | | operator!=(complex<T1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | | typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_NotEqual<complex<T1> , _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_NotEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1
), | |
| d2)); | | d2)); | |
| } | | } | |
| #endif // BZ_HAVE_COMPLEX | | #endif // BZ_HAVE_COMPLEX | |
| | | | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Logical AND operators | | * Logical AND operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| | | | |
| skipping to change at line 5083 | | skipping to change at line 5083 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> && _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> && _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalAnd<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator&&(const Matrix<P_numtype1, P_struct1>& d1, | | operator&&(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalAnd<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> && int | | // Matrix<P_numtype1, P_struct1> && int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 5117 | | skipping to change at line 5117 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> && Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> && Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_LogicalAnd<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator&&(_bz_MatExpr<P_expr1> d1, | | operator&&(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_LogicalAnd<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> && _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> && _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalAnd<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2:
:T_numtype > > > | | _bz_LogicalAnd<typename P_expr1::T_numtype, typename P_expr2::T_numty
pe > > > | |
| operator&&(_bz_MatExpr<P_expr1> d1, | | operator&&(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalAnd<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2:
:T_numtype> > T_expr; | | _bz_LogicalAnd<typename P_expr1::T_numtype, typename P_expr2::T_numty
pe> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> && int | | // _bz_MatExpr<P_expr1> && int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_LogicalAnd<_bz_typename P_expr1::T_numtype, int > > > | | _bz_LogicalAnd<typename P_expr1::T_numtype, int > > > | |
| operator&&(_bz_MatExpr<P_expr1> d1, | | operator&&(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_LogicalAnd<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_LogicalAnd<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // int && Matrix<P_numtype2, P_struct2> | | // int && Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 5185 | | skipping to change at line 5185 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int && _bz_MatExpr<P_expr2> | | // int && _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalAnd<int, _bz_typename P_expr2::T_numtype > > > | | _bz_LogicalAnd<int, typename P_expr2::T_numtype > > > | |
| operator&&(int d1, | | operator&&(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalAnd<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_LogicalAnd<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2)); | | d2)); | |
| } | | } | |
| /**************************************************************************
** | | /**************************************************************************
** | |
| * Logical OR operators | | * Logical OR operators | |
| **************************************************************************
**/ | | **************************************************************************
**/ | |
| | | | |
| // Matrix<P_numtype1, P_struct1> || Matrix<P_numtype2, P_struct2> | | // Matrix<P_numtype1, P_struct1> || Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | | template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc
t2> | |
| | | | |
| skipping to change at line 5222 | | skipping to change at line 5222 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> || _bz_MatExpr<P_expr2> | | // Matrix<P_numtype1, P_struct1> || _bz_MatExpr<P_expr2> | |
| template<class P_numtype1, class P_struct1, class P_expr2> | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalOr<P_numtype1, _bz_typename P_expr2::T_numtype > > > | | _bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype > > > | |
| operator||(const Matrix<P_numtype1, P_struct1>& d1, | | operator||(const Matrix<P_numtype1, P_struct1>& d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalOr<P_numtype1, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // Matrix<P_numtype1, P_struct1> || int | | // Matrix<P_numtype1, P_struct1> || int | |
| template<class P_numtype1, class P_struct1> | | template<class P_numtype1, class P_struct1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
| | | | |
| skipping to change at line 5256 | | skipping to change at line 5256 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> || Matrix<P_numtype2, P_struct2> | | // _bz_MatExpr<P_expr1> || Matrix<P_numtype2, P_struct2> | |
| template<class P_expr1, class P_numtype2, class P_struct2> | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_LogicalOr<_bz_typename P_expr1::T_numtype, P_numtype2 > > > | | _bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2 > > > | |
| operator||(_bz_MatExpr<P_expr1> d1, | | operator||(_bz_MatExpr<P_expr1> d1, | |
| const Matrix<P_numtype2, P_struct2>& d2) | | const Matrix<P_numtype2, P_struct2>& d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
|
| _bz_LogicalOr<_bz_typename P_expr1::T_numtype, P_numtype2> > T_expr; | | _bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> || _bz_MatExpr<P_expr2> | | // _bz_MatExpr<P_expr1> || _bz_MatExpr<P_expr2> | |
| template<class P_expr1, class P_expr2> | | template<class P_expr1, class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalOr<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::
T_numtype > > > | | _bz_LogicalOr<typename P_expr1::T_numtype, typename P_expr2::T_numtyp
e > > > | |
| operator||(_bz_MatExpr<P_expr1> d1, | | operator||(_bz_MatExpr<P_expr1> d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalOr<_bz_typename P_expr1::T_numtype, _bz_typename P_expr2::
T_numtype> > T_expr; | | _bz_LogicalOr<typename P_expr1::T_numtype, typename P_expr2::T_numtyp
e> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| d2)); | | d2)); | |
| } | | } | |
| | | | |
| // _bz_MatExpr<P_expr1> || int | | // _bz_MatExpr<P_expr1> || int | |
| template<class P_expr1> | | template<class P_expr1> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_LogicalOr<_bz_typename P_expr1::T_numtype, int > > > | | _bz_LogicalOr<typename P_expr1::T_numtype, int > > > | |
| operator||(_bz_MatExpr<P_expr1> d1, | | operator||(_bz_MatExpr<P_expr1> d1, | |
| int d2) | | int d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| _bz_MatExprConstant<int>, | | _bz_MatExprConstant<int>, | |
|
| _bz_LogicalOr<_bz_typename P_expr1::T_numtype, int> > T_expr; | | _bz_LogicalOr<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(d1, | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| _bz_MatExprConstant<int>(d2))); | | _bz_MatExprConstant<int>(d2))); | |
| } | | } | |
| | | | |
| // int || Matrix<P_numtype2, P_struct2> | | // int || Matrix<P_numtype2, P_struct2> | |
| template<class P_numtype2, class P_struct2> | | template<class P_numtype2, class P_struct2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatrixRef<P_numtype2, P_struct2>, | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | | |
| skipping to change at line 5324 | | skipping to change at line 5324 | |
| | | | |
| return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| d2._bz_getRef())); | | d2._bz_getRef())); | |
| } | | } | |
| | | | |
| // int || _bz_MatExpr<P_expr2> | | // int || _bz_MatExpr<P_expr2> | |
| template<class P_expr2> | | template<class P_expr2> | |
| inline | | inline | |
| _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalOr<int, _bz_typename P_expr2::T_numtype > > > | | _bz_LogicalOr<int, typename P_expr2::T_numtype > > > | |
| operator||(int d1, | | operator||(int d1, | |
| _bz_MatExpr<P_expr2> d2) | | _bz_MatExpr<P_expr2> d2) | |
| { | | { | |
| typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| _bz_MatExpr<P_expr2>, | | _bz_MatExpr<P_expr2>, | |
|
| _bz_LogicalOr<int, _bz_typename P_expr2::T_numtype> > T_expr; | | _bz_LogicalOr<int, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| | | d2)); | |
| | | } | |
| | | /************************************************************************** | |
| | | ** | |
| | | * Minimum Operators | |
| | | ************************************************************************** | |
| | | **/ | |
| | | | |
| | | // Matrix<P_numtype1, P_struct1> min Matrix<P_numtype2, P_struct2> | |
| | | template<class P_numtype1, class P_struct1, class P_numtype2, class P_struc | |
| | | t2> | |
| | | inline | |
| | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | _bz_Min<P_numtype1, P_numtype2 > > > | |
| | | min(const Matrix<P_numtype1, P_struct1>& d1, | |
| | | const Matrix<P_numtype2, P_struct2>& d2) | |
| | | { | |
| | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | _bz_Min<P_numtype1, P_numtype2> > T_expr; | |
| | | | |
| | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| | | d2._bz_getRef())); | |
| | | } | |
| | | | |
| | | // Matrix<P_numtype1, P_struct1> min _bz_MatExpr<P_expr2> | |
| | | template<class P_numtype1, class P_struct1, class P_expr2> | |
| | | inline | |
| | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| | | _bz_MatExpr<P_expr2>, | |
| | | _bz_Min<P_numtype1, typename P_expr2::T_numtype > > > | |
| | | min(const Matrix<P_numtype1, P_struct1>& d1, | |
| | | _bz_MatExpr<P_expr2> d2) | |
| | | { | |
| | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| | | _bz_MatExpr<P_expr2>, | |
| | | _bz_Min<P_numtype1, typename P_expr2::T_numtype> > T_expr; | |
| | | | |
| | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| | | d2)); | |
| | | } | |
| | | | |
| | | // Matrix<P_numtype1, P_struct1> min int | |
| | | template<class P_numtype1, class P_struct1> | |
| | | inline | |
| | | _bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| | | _bz_MatExprConstant<int>, | |
| | | _bz_Min<P_numtype1, int > > > | |
| | | min(const Matrix<P_numtype1, P_struct1>& d1, | |
| | | int d2) | |
| | | { | |
| | | typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, | |
| | | _bz_MatExprConstant<int>, | |
| | | _bz_Min<P_numtype1, int> > T_expr; | |
| | | | |
| | | return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), | |
| | | _bz_MatExprConstant<int>(d2))); | |
| | | } | |
| | | | |
| | | // _bz_MatExpr<P_expr1> min Matrix<P_numtype2, P_struct2> | |
| | | template<class P_expr1, class P_numtype2, class P_struct2> | |
| | | inline | |
| | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | _bz_Min<typename P_expr1::T_numtype, P_numtype2 > > > | |
| | | min(_bz_MatExpr<P_expr1> d1, | |
| | | const Matrix<P_numtype2, P_struct2>& d2) | |
| | | { | |
| | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | _bz_Min<typename P_expr1::T_numtype, P_numtype2> > T_expr; | |
| | | | |
| | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| | | d2._bz_getRef())); | |
| | | } | |
| | | | |
| | | // _bz_MatExpr<P_expr1> min _bz_MatExpr<P_expr2> | |
| | | template<class P_expr1, class P_expr2> | |
| | | inline | |
| | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| | | _bz_MatExpr<P_expr2>, | |
| | | _bz_Min<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > | |
| | | > | |
| | | min(_bz_MatExpr<P_expr1> d1, | |
| | | _bz_MatExpr<P_expr2> d2) | |
| | | { | |
| | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| | | _bz_MatExpr<P_expr2>, | |
| | | _bz_Min<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T | |
| | | _expr; | |
| | | | |
| | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| | | d2)); | |
| | | } | |
| | | | |
| | | // _bz_MatExpr<P_expr1> min int | |
| | | template<class P_expr1> | |
| | | inline | |
| | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| | | _bz_MatExprConstant<int>, | |
| | | _bz_Min<typename P_expr1::T_numtype, int > > > | |
| | | min(_bz_MatExpr<P_expr1> d1, | |
| | | int d2) | |
| | | { | |
| | | typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, | |
| | | _bz_MatExprConstant<int>, | |
| | | _bz_Min<typename P_expr1::T_numtype, int> > T_expr; | |
| | | | |
| | | return _bz_MatExpr<T_expr>(T_expr(d1, | |
| | | _bz_MatExprConstant<int>(d2))); | |
| | | } | |
| | | | |
| | | // int min Matrix<P_numtype2, P_struct2> | |
| | | template<class P_numtype2, class P_struct2> | |
| | | inline | |
| | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | _bz_Min<int, P_numtype2 > > > | |
| | | min(int d1, | |
| | | const Matrix<P_numtype2, P_struct2>& d2) | |
| | | { | |
| | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | _bz_MatrixRef<P_numtype2, P_struct2>, | |
| | | _bz_Min<int, P_numtype2> > T_expr; | |
| | | | |
| | | return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), | |
| | | d2._bz_getRef())); | |
| | | } | |
| | | | |
| | | // int min _bz_MatExpr<P_expr2> | |
| | | template<class P_expr2> | |
| | | inline | |
| | | _bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | _bz_MatExpr<P_expr2>, | |
| | | _bz_Min<int, typename P_expr2::T_numtype > > > | |
| | | min(int d1, | |
| | | _bz_MatExpr<P_expr2> d2) | |
| | | { | |
| | | typedef _bz_MatExprOp<_bz_MatExprConstant<int>, | |
| | | _bz_MatExpr<P_expr2>, | |
| | | _bz_Min<int, typename P_expr2::T_numtype> > T_expr; | |
| |