FreePOOMA  2.4.1
Functions
ArrayOperators.h File Reference
This graph shows which files directly or indirectly include this file:

Functions

template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode
< FnArcCos, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t > >::Expression_t 
acos (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode
< FnArcSin, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t > >::Expression_t 
asin (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode
< FnArcTan, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t > >::Expression_t 
atan (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< FnCeil,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
ceil (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< FnCos,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
cos (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode
< FnHypCos, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t > >::Expression_t 
cosh (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< FnExp,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
exp (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< FnFabs,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
fabs (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< FnFloor,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
floor (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< FnLog,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
log (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< FnLog10,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
log10 (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< FnSin,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
sin (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode
< FnHypSin, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t > >::Expression_t 
sinh (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< FnSqrt,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
sqrt (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< FnTan,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
tan (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode
< FnHypTan, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t > >::Expression_t 
tanh (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode
< OpUnaryMinus, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t > >::Expression_t 
operator- (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode
< OpUnaryPlus, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t > >::Expression_t 
operator+ (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode
< OpBitwiseNot, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t > >::Expression_t 
operator~ (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode
< OpIdentity, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t > >::Expression_t 
PETE_identity (const Array< D1, T1, E1 > &l)
template<int D1, class T1 , class E1 >
MakeReturn< UnaryNode< OpNot,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t >
>::Expression_t 
operator! (const Array< D1, T1, E1 > &l)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< UnaryNode< OpCast
< T1 >, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
peteCast (const T1 &, const Array< D2, T2, E2 > &l)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpAdd,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator+ (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpSubtract, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator- (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpMultiply, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator* (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpDivide, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator/ (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpMod,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator% (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpBitwiseAnd, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator& (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpBitwiseOr, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator| (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpBitwiseXor, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator^ (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< FnLdexp, typename CreateLeaf
< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
ldexp (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< FnPow,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
pow (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< FnFmod,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
fmod (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< FnArcTan2, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
atan2 (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpLT,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator< (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpLE,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator<= (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpGT,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator> (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpGE,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator>= (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpEQ,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator== (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpNE,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator!= (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpAnd,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator&& (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpOr,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator|| (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpLeftShift, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator<< (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpRightShift, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator>> (const Array< D1, T1, E1 > &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< OpAdd,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator+ (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode
< OpSubtract, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator- (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode
< OpMultiply, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator* (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode
< OpDivide, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator/ (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< OpMod,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator% (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode
< OpBitwiseAnd, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator& (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode
< OpBitwiseOr, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator| (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode
< OpBitwiseXor, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator^ (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode
< FnLdexp, typename CreateLeaf
< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
ldexp (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< FnPow,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
pow (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< FnFmod,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
fmod (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode
< FnArcTan2, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
atan2 (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< OpLT,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator< (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< OpLE,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator<= (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< OpGT,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator> (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< OpGE,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator>= (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< OpEQ,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator== (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< OpNE,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator!= (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< OpAnd,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator&& (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode< OpOr,
typename CreateLeaf< Array< D1,
T1, E1 > >::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator|| (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode
< OpLeftShift, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator<< (const Array< D1, T1, E1 > &l, const T2 &r)
template<int D1, class T1 , class E1 , class T2 >
MakeReturn< BinaryNode
< OpRightShift, typename
CreateLeaf< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t >
>::Expression_t 
operator>> (const Array< D1, T1, E1 > &l, const T2 &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpAdd,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator+ (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpSubtract, typename
CreateLeaf< T1 >::Leaf_t,
typename CreateLeaf< Array< D2,
T2, E2 > >::Leaf_t >
>::Expression_t 
operator- (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpMultiply, typename
CreateLeaf< T1 >::Leaf_t,
typename CreateLeaf< Array< D2,
T2, E2 > >::Leaf_t >
>::Expression_t 
operator* (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpDivide, typename
CreateLeaf< T1 >::Leaf_t,
typename CreateLeaf< Array< D2,
T2, E2 > >::Leaf_t >
>::Expression_t 
operator/ (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpMod,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator% (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpBitwiseAnd, typename
CreateLeaf< T1 >::Leaf_t,
typename CreateLeaf< Array< D2,
T2, E2 > >::Leaf_t >
>::Expression_t 
operator& (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpBitwiseOr, typename
CreateLeaf< T1 >::Leaf_t,
typename CreateLeaf< Array< D2,
T2, E2 > >::Leaf_t >
>::Expression_t 
operator| (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< OpBitwiseXor, typename
CreateLeaf< T1 >::Leaf_t,
typename CreateLeaf< Array< D2,
T2, E2 > >::Leaf_t >
>::Expression_t 
operator^ (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< FnLdexp, typename CreateLeaf
< T1 >::Leaf_t, typename
CreateLeaf< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
ldexp (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< FnPow,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
pow (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< FnFmod,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
fmod (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode
< FnArcTan2, typename
CreateLeaf< T1 >::Leaf_t,
typename CreateLeaf< Array< D2,
T2, E2 > >::Leaf_t >
>::Expression_t 
atan2 (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpLT,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator< (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpLE,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator<= (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpGT,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator> (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpGE,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator>= (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpEQ,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator== (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpNE,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator!= (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpAnd,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator&& (const T1 &l, const Array< D2, T2, E2 > &r)
template<class T1 , int D2, class T2 , class E2 >
MakeReturn< BinaryNode< OpOr,
typename CreateLeaf< T1 >
::Leaf_t, typename CreateLeaf
< Array< D2, T2, E2 >
>::Leaf_t > >::Expression_t 
operator|| (const T1 &l, const Array< D2, T2, E2 > &r)
template<int D1, class T1 , class E1 , class T2 , class T3 >
MakeReturn< TrinaryNode
< FnWhere, typename CreateLeaf
< Array< D1, T1, E1 >
>::Leaf_t, typename
CreateLeaf< T2 >::Leaf_t,
typename CreateLeaf< T3 >
::Leaf_t > >::Expression_t 
where (const Array< D1, T1, E1 > &c, const T2 &t, const T3 &f)

Function Documentation

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnArcCos, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t acos ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnArcCos::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnArcSin, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t asin ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnArcSin::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnArcTan, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t atan ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnArcTan::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnCeil, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t ceil ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnCeil::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnCos, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t cos ( const Array< D1, T1, E1 > &  l) [inline]
template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnHypCos, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t cosh ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnHypCos::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnExp, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t exp ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnExp::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnFabs, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t fabs ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnFabs::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnFloor, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t floor ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnFloor::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnLog, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t log ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnLog::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnLog10, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t log10 ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnLog10::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnSin, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t sin ( const Array< D1, T1, E1 > &  l) [inline]
template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnHypSin, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t sinh ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnHypSin::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnSqrt, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t sqrt ( const Array< D1, T1, E1 > &  l) [inline]
template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnTan, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t tan ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnTan::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<FnHypTan, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t tanh ( const Array< D1, T1, E1 > &  l) [inline]

References MakeReturn< T >::make().

Referenced by FnHypTan::operator()().

template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<OpUnaryMinus, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t operator- ( const Array< D1, T1, E1 > &  l) [inline]
template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<OpUnaryPlus, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t operator+ ( const Array< D1, T1, E1 > &  l) [inline]
template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<OpBitwiseNot, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t operator~ ( const Array< D1, T1, E1 > &  l) [inline]
template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<OpIdentity, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t PETE_identity ( const Array< D1, T1, E1 > &  l) [inline]
template<int D1, class T1 , class E1 >
MakeReturn<UnaryNode<OpNot, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t operator! ( const Array< D1, T1, E1 > &  l) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<UnaryNode<OpCast<T1>, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t peteCast ( const T1 &  ,
const Array< D2, T2, E2 > &  l 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpAdd, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator+ ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpSubtract, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator- ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpMultiply, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator* ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpDivide, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator/ ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpMod, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator% ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseAnd, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator& ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseOr, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator| ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseXor, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator^ ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<FnLdexp, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t ldexp ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]

References MakeReturn< T >::make().

Referenced by FnLdexp::operator()().

template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<FnPow, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t pow ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]

References MakeReturn< T >::make().

Referenced by FnPow::operator()().

template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<FnFmod, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t fmod ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]

References MakeReturn< T >::make().

Referenced by FnFmod::operator()().

template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<FnArcTan2, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t atan2 ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpLT, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator< ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpLE, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator<= ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpGT, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator> ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpGE, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator>= ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpEQ, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator== ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpNE, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator!= ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpAnd, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator&& ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpOr, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator|| ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpLeftShift, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator<< ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpRightShift, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator>> ( const Array< D1, T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpAdd, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator+ ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpSubtract, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator- ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpMultiply, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator* ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpDivide, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator/ ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpMod, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator% ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpBitwiseAnd, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator& ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpBitwiseOr, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator| ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpBitwiseXor, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator^ ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<FnLdexp, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t ldexp ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<FnPow, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t pow ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<FnFmod, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t fmod ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<FnArcTan2, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t atan2 ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpLT, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator< ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpLE, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator<= ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpGT, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator> ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpGE, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator>= ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpEQ, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator== ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpNE, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator!= ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpAnd, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator&& ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpOr, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator|| ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpLeftShift, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator<< ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpRightShift, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator>> ( const Array< D1, T1, E1 > &  l,
const T2 &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpAdd, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator+ ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpSubtract, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator- ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpMultiply, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator* ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpDivide, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator/ ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpMod, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator% ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseAnd, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator& ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseOr, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator| ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseXor, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator^ ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<FnLdexp, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t ldexp ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<FnPow, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t pow ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<FnFmod, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t fmod ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<FnArcTan2, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t atan2 ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpLT, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator< ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpLE, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator<= ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpGT, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator> ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpGE, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator>= ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpEQ, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator== ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpNE, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator!= ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpAnd, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator&& ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<class T1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpOr, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator|| ( const T1 &  l,
const Array< D2, T2, E2 > &  r 
) [inline]
template<int D1, class T1 , class E1 , class T2 , class T3 >
MakeReturn<TrinaryNode<FnWhere, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t, typename CreateLeaf<T3 >::Leaf_t> >::Expression_t where ( const Array< D1, T1, E1 > &  c,
const T2 &  t,
const T3 &  f 
) [inline]