DynamicArrayOperators.h File Reference

This graph shows which files directly or indirectly include this file:


Functions

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

Function Documentation

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<class T1 , class E1 >
MakeReturn<UnaryNode<OpUnaryMinus, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t> >::Expression_t operator- ( const DynamicArray< T1, E1 > &  l  )  [inline]

template<class T1 , class E1 >
MakeReturn<UnaryNode<OpUnaryPlus, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t> >::Expression_t operator+ ( const DynamicArray< T1, E1 > &  l  )  [inline]

template<class T1 , class E1 >
MakeReturn<UnaryNode<OpBitwiseNot, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t> >::Expression_t operator~ ( const DynamicArray< T1, E1 > &  l  )  [inline]

template<class T1 , class E1 >
MakeReturn<UnaryNode<OpIdentity, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t> >::Expression_t PETE_identity ( const DynamicArray< T1, E1 > &  l  )  [inline]

template<class T1 , class E1 >
MakeReturn<UnaryNode<OpNot, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t> >::Expression_t operator! ( const DynamicArray< T1, E1 > &  l  )  [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<UnaryNode<OpCast<T1>, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t peteCast ( const T1 &  ,
const DynamicArray< T2, E2 > &  l 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpAdd, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator+ ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpSubtract, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator- ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpMultiply, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator* ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpDivide, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator/ ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpMod, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator% ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseAnd, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator& ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseOr, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator| ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseXor, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator^ ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<FnLdexp, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t ldexp ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

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

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

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<FnArcTan2, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t atan2 ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpLT, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator< ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpLE, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator<= ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpGT, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator> ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpGE, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator>= ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpEQ, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator== ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpNE, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator!= ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpAnd, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator&& ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpOr, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator|| ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpLeftShift, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator<< ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpRightShift, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator>> ( const DynamicArray< T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int D1, class T1 , class E1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpNE, typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator!= ( const Array< D1, T1, E1 > &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<class T1 , class E1 , int D2, class T2 , class E2 >
MakeReturn<BinaryNode<OpNE, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<Array<D2,T2,E2> >::Leaf_t> >::Expression_t operator!= ( const DynamicArray< T1, E1 > &  l,
const Array< D2, T2, E2 > &  r 
) [inline]

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

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

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

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

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpAdd, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator+ ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpSubtract, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator- ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpMultiply, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator* ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpDivide, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator/ ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpMod, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator% ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpBitwiseAnd, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator& ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpBitwiseOr, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator| ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpBitwiseXor, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator^ ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<FnLdexp, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t ldexp ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

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

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

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<FnArcTan2, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t atan2 ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpLT, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator< ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpLE, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator<= ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpGT, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator> ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpGE, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator>= ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpEQ, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator== ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpNE, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator!= ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpAnd, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator&& ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpOr, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator|| ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpLeftShift, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator<< ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class E1 , class T2 >
MakeReturn<BinaryNode<OpRightShift, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t> >::Expression_t operator>> ( const DynamicArray< T1, E1 > &  l,
const T2 &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpAdd, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator+ ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpSubtract, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator- ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpMultiply, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator* ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpDivide, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator/ ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpMod, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator% ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseAnd, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator& ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseOr, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator| ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpBitwiseXor, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator^ ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<FnLdexp, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t ldexp ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

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

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

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<FnArcTan2, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t atan2 ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpLT, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator< ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpLE, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator<= ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpGT, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator> ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpGE, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator>= ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpEQ, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator== ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpNE, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator!= ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpAnd, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator&& ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class T2 , class E2 >
MakeReturn<BinaryNode<OpOr, typename CreateLeaf<T1 >::Leaf_t, typename CreateLeaf<DynamicArray<T2,E2> >::Leaf_t> >::Expression_t operator|| ( const T1 &  l,
const DynamicArray< T2, E2 > &  r 
) [inline]

template<class T1 , class E1 , class T2 , class T3 >
MakeReturn<TrinaryNode<FnWhere, typename CreateLeaf<DynamicArray<T1,E1> >::Leaf_t, typename CreateLeaf<T2 >::Leaf_t, typename CreateLeaf<T3 >::Leaf_t> >::Expression_t where ( const DynamicArray< T1, E1 > &  c,
const T2 &  t,
const T3 &  f 
) [inline]


Generated on Wed Mar 16 06:17:03 2011 for FreePOOMA by  doxygen 1.5.9